#include <dnaadjust.hpp>

Collaboration diagram for dynadjust::networkadjust::dna_adjust:

Public Member Functions
	dna_adjust ()

virtual	~dna_adjust ()

void	ShrinkForwardMatrices (const UINT32 currentBlock)

void	CarryForwardJunctions (const UINT32 currentBlock, const UINT32 nextBlock)

bool	CarryReverseJunctions (const UINT32 currentBlock, const UINT32 nextBlock, bool MT_ReverseOrCombine)

void	PrepareAdjustmentMultiThread ()

void	PrepareAdjustmentBlock (const UINT32 block, const UINT32 thread_id=0)

bool	PrepareAdjustmentReverse (const UINT32 block, bool MT_ReverseOrCombine)

bool	PrepareAdjustmentCombine (const UINT32 block, UINT32 &pseudomsrJSLCount, bool MT_ReverseOrCombine)

void	BackupNormals (const UINT32 block, bool MT_ReverseOrCombine)

void	UpdateEstimatesForward (const UINT32 block)

void	UpdateEstimatesReverse (const UINT32 block, bool MT_ReverseOrCombine)

void	UpdateEstimatesCombine (const UINT32 block, UINT32 prevJSLCount)

void	UpdateEstimatesFinal (const UINT32 currentBlock)

void	UpdateEstimatesFinalNoCombine ()

void	GenerateStatistics ()

void	PrepareAdjustment (const project_settings &adjustmentSettings)

void	CancelAdjustment ()

bool	IsCancelled () const

_ADJUST_STATUS_	GetStatus () const

bool	IsPreparing ()

bool	IsAdjusting ()

bool	ExceptionRaised ()

void	PrintAdjustedNetworkStations ()

void	PrintPositionalUncertainty ()

void	PrintNetworkStationCorrections ()

void	PrintAdjustedNetworkMeasurements ()

void	PrintMeasurementsToStation ()

bool	PrintEstimatedStationCoordinatestoSNX (std::string &sinex_file)

void	PrintEstimatedStationCoordinatestoDNAXML (const std::string &stnFile, INPUT_FILE_TYPE t, bool flagUnused=false)

void	PrintEstimatedStationCoordinatestoDNAXML_Y (const std::string &msrFile, INPUT_FILE_TYPE t)

void	CloseOutputFiles ()

void	UpdateBinaryFiles ()

UINT32	CurrentIteration () const

UINT32 &	incrementIteration ()

void	initialiseIteration (const UINT32 &iteration=0)

UINT32	CurrentBlock () const

void	SetcurrentBlock (const UINT32 b)

void	SetmaxCorr (const double c)

UINT32	blockCount () const

boost::posix_time::milliseconds	adjustTime () const

bool	processingForward ()

bool	processingCombine ()

int	GetDegreesOfFreedom () const

UINT32	GetMeasurementCount () const

UINT32	GetUnknownsCount () const

double	GetChiSquared () const

double	GetSigmaZero () const

UINT32	GetPotentialOutlierCount () const

double	GetChiSquaredUpperLimit () const

double	GetChiSquaredLowerLimit () const

double	GetGlobalPelzerRel () const

UINT32	GetTestResult () const

bool	GetAllFixed () const

void	GetMemoryFootprint (double &memory, const _MEM_UNIT_ unit)

void	LoadSegmentationFileParameters (const std::string &seg_filename)

void	SerialiseAdjustedVarianceMatrices ()

void	DeSerialiseAdjustedVarianceMatrices ()

bool	NewMessagesAvailable ()

bool	GetMessageIteration (UINT32 &iteration)

std::string	GetMaxCorrection (const UINT32 &iteration) const

void	ThreadSafeWritetoAdjFile (const std::string &s)

void	WriteStatstoAdjFile (const std::string &s)

void	WriteStntoAdjFile (const std::string &s)

void	WriteMsrtoAdjFile (const std::string &s)

void	ThreadSafeWritetoDbgFile (const std::string &s)

_ADJUST_STATUS_	AdjustNetwork ()

bool	FirstBlock (const UINT32 &block) const

bool	LastBlock (const UINT32 &block) const

void	SignalExceptionAdjustment (const std::string &msg, const UINT32 block_no)

void	CreateMeasurementTally (const UINT32 &block=0)

void	SolveTry (bool COMPUTE_INVERSE, const UINT32 &block=0)

void	SolveMTTry (bool COMPUTE_INVERSE, const UINT32 &block=0)

void	Solve (bool COMPUTE_INVERSE, const UINT32 &block=0)

void	SolveMT (bool COMPUTE_INVERSE, const UINT32 &block)

bool	CombineRequired (const UINT32 &block) const

Public Attributes
concurrent_ofstream< std::string >	concurrent_adj_ofstream

bool	isPreparing_

bool	isAdjusting_

bool	isCombining_

bool	forward_

bool	isFirstTimeAdjustment_

bool	isIterationComplete_

bool	isAdjustmentQuestionable_

UINT32	blockCount_

UINT32	currentBlock_

boost::posix_time::milliseconds	total_time_

_ADJUST_STATUS_	adjustStatus_

vstring	statusMessages_

UINT32	currentIteration_

std::vector< blockMeta_t >	v_blockMeta_

Private Member Functions
	dna_adjust (const dna_adjust &)

dna_adjust &	operator= (const dna_adjust &)

bool	InitialiseandValidateMsrPointer (const it_vUINT32 &_it_block_msr, it_vmsr_t &_it_msr)

bool	InitialiseMeasurement (pit_vmsr_t _it_msr, bool buildnewMatrices)

void	RebuildNormals (const UINT32 block, adjustOperation direction, bool AddConstraintStationstoNormals, bool BackupNormals)

void	UpdateAdjustment (bool iterate)

void	ValidateandFinaliseAdjustment (boost::timer::cpu_timer &tot_time)

void	PrintAdjustmentStatus ()

void	PrintAdjustmentTime (boost::timer::cpu_timer &time, _TIMER_TYPE_)

void	PrintIteration (const UINT32 &iteration)

void	InitialiseAdjustment ()

void	SetDefaultReferenceFrame ()

void	LoadNetworkFiles ()

void	CreateMsrToStnTally ()

void	AdjustSimultaneous ()

void	AdjustPhased ()

void	AdjustPhasedForward ()

void	AdjustPhasedReverseCombine ()

bool	CombinationThreadRequired ()

void	AdjustPhasedMultiThread ()

void	AdjustPhasedBlock1 ()

void	AdjustPhasedReverse ()

void	ApplyAdditionalConstraints ()

void	AddDiscontinuitySites (vstring &constraintStns)

void	LoadStationMap (pv_string_uint32_pair stnsMap, const std::string &stnmap_file)

void	ResizeMatrixVectors ()

void	LoadPhasedBlocks ()

void	LoadSegmentationFile ()

void	LoadSegmentationMetrics ()

void	RemoveInvalidISLStations (vUINT32 &v_ISLTemp)

void	RemoveNonMeasurements (const UINT32 &block)

void	RemoveDuplicateStations (vUINT32 &vStns)

void	InitialiseTypeBUncertainties ()

void	SortMeasurementsbyType (v_uint32_u32u32_pair &msr_block)

void	SortMeasurementsbyFromStn (v_uint32_u32u32_pair &msr_block)

void	SortMeasurementsbyToStn (v_uint32_u32u32_pair &msr_block)

void	SortMeasurementsbyValue (v_uint32_u32u32_pair &msr_block)

void	SortMeasurementsbyResidual (v_uint32_u32u32_pair &msr_block)

void	SortMeasurementsbyAdjSD (v_uint32_u32u32_pair &msr_block)

void	SortMeasurementsbyNstat (v_uint32_u32u32_pair &msr_block)

void	SortStationsbyFileOrder (vUINT32 &v_blockStations)

void	SortStationsbyID (vUINT32 &v_blockStations)

void	SetRegionOffsets (const UINT32 &block, const int file_count=0,...)

void	SetRegionOffset (vmat_file_map &file_map)

void	SetMapRegions (const int file_count=0,...)

void	PrepareMemoryMapRegions (const UINT32 &block, const int file_count=0,...)

void	OffloadBlockToDisk (const UINT32 &block)

void	OffloadBlockToMappedFile (const UINT32 &block)

void	SerialiseBlockToDisk (const UINT32 &block)

void	SerialiseBlockToMappedFile (const UINT32 &block, const int file_count=0,...)

void	DeserialiseBlockFromMappedFile (const UINT32 &block, const int count=0,...)

void	UnloadBlock (const UINT32 &block, const int file_count=0,...)

void	PurgeMatricesFromDisk ()

void	AddMsrtoMeasMinusComp (pit_vmsr_t _it_msr, const UINT32 &design_row, const double comp_msr, matrix_2d *measMinusComp, bool printBlock=true)

void	AddMsrtoNormalsVar (const UINT32 &design_row, const UINT32 &stn, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv)

void	AddMsrtoNormalsCoVar2 (const UINT32 &design_row, const UINT32 &stn1, const UINT32 &stn2, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv)

void	AddMsrtoNormalsCoVar3 (const UINT32 &design_row, const UINT32 &stn1, const UINT32 &stn2, const UINT32 &stn3, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv)

void	AddMsrtoDesign (const UINT32 &design_row, const UINT32 &stn, const double &dmdx, const double &dmdy, const double &dmdz, matrix_2d *design)

void	AddMsrtoDesign_L (const UINT32 &design_row, const UINT32 &stn1, const UINT32 &stn2, const double dmdx1, const double dmdy1, const double dmdz1, const double dmdx2, const double dmdy2, const double dmdz2, matrix_2d *design)

void	AddMsrtoDesign_BCEKMSVZ (const UINT32 &design_row, const UINT32 &stn1, const UINT32 &stn2, const double dmdx, const double dmdy, const double dmdz, matrix_2d *design)

void	AddElementtoDesign (const UINT32 &row, const UINT32 &col, const double value, matrix_2d *design)

void	UpdateDesignNormalMeasMatrices (pit_vmsr_t _it_msr, UINT32 &design_row, bool buildnewMatrices, const UINT32 &block, bool MT_ReverseOrCombine)

void	UpdateDesignNormalMeasMatrices_A (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_BK (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_C (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_CEM (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_D (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_E (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignMeasMatrices_GX (pit_vmsr_t _it_msr, UINT32 &design_row, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d *design, const UINT32 &stn1, const UINT32 &stn2, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_G (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_H (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_HR (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_I (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_IP (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_J (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_JQ (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_L (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_M (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_P (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_Q (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_R (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_S (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_V (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_X (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d design, matrix_2d AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_Y (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d design, matrix_2d AtVinv, bool buildnewMatrices)

void	UpdateDesignNormalMeasMatrices_Z (pit_vmsr_t _it_msr, UINT32 &design_row, const UINT32 &block, matrix_2d measMinusComp, matrix_2d estimatedStations, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv, bool buildnewMatrices)

bool	IgnoredMeasurementContainsInvalidStation (pit_vmsr_t _it_msr)

void	UpdateIgnoredMeasurements (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_A (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_B (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_BK (pit_vmsr_t _it_msr)

void	UpdateIgnoredMeasurements_C (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_CEM (pit_vmsr_t _it_msr)

void	UpdateIgnoredMeasurements_D (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_E (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_G (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_GX (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_H (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_HR (pit_vmsr_t _it_msr)

void	UpdateIgnoredMeasurements_I (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_IP (pit_vmsr_t _it_msr)

void	UpdateIgnoredMeasurements_J (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_JQ (pit_vmsr_t _it_msr)

void	UpdateIgnoredMeasurements_K (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_L (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_M (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_P (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_Q (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_R (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_S (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_V (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_X (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_Y (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	UpdateIgnoredMeasurements_Z (pit_vmsr_t _it_msr, bool storeOriginalMeasurement)

void	LoadVarianceScaling (it_vmsr_t _it_msr, double &vScale, double &pScale, double &lScale, double &hScale, bool &scaleMatrix, bool &scalePartial)

void	LoadVarianceMatrix_D (it_vmsr_t _it_msr, matrix_2d *var_dirn, bool buildnewMatrices)

void	LoadVarianceMatrix_G (it_vmsr_t _it_msr, matrix_2d *var_cart)

void	LoadVarianceMatrix_X (it_vmsr_t _it_msr, matrix_2d *var_cart)

void	LoadVarianceMatrix_Y (it_vmsr_t _it_msr, matrix_2d *var_cart, const _COORD_TYPE_ coordType)

void	PrintMsrVarianceMatrixException (const it_vmsr_t &_it_msr, const std::runtime_error &e, std::stringstream &ss, const std::string &calling_function, const UINT32 msr_count=0)

void	PrepareStationandVarianceMatrices (const UINT32 &block)

void	PrepareMappedRegions (const UINT32 &block)

void	PopulateEstimatedStationMatrix (const UINT32 &block, UINT32 &unknownParams)

void	CarryStnEstimatesandVariancesForward (const UINT32 &thisBlock, const UINT32 &nextBlock)

void	CarryStnEstimatesandVariancesReverse (const UINT32 &nextBlock, const UINT32 &thisBlock, bool MT_ReverseOrCombine)

void	CarryStnEstimatesandVariancesCombine (const UINT32 &nextBlock, const UINT32 &thisBlock, UINT32 &pseudomsrJSLCount, bool MT_ReverseOrCombine)

void	UpdateAtVinv (pit_vmsr_t _it_msr, const UINT32 &stn1, const UINT32 &stn2, const UINT32 &stn3, UINT32 &design_row, matrix_2d design, matrix_2d AtVinv, bool buildnewMatrices=true)

void	UpdateAtVinv_D (const UINT32 &stn1, const UINT32 &stn2, const UINT32 &stn3, const UINT32 &angle, const UINT32 &angle_count, UINT32 &design_row, UINT32 &design_row_begin, matrix_2d Vinv, matrix_2d design, matrix_2d *AtVinv)

void	UpdateNormals (const UINT32 &block, bool MT_ReverseOrCombine)

void	UpdateNormals_A (const UINT32 &stn1, const UINT32 &stn2, const UINT32 &stn3, UINT32 &design_row, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv)

void	UpdateNormals_BCEKLMSVZ (const UINT32 &stn1, const UINT32 &stn2, UINT32 &design_row, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv)

void	UpdateNormals_HIJPQR (const UINT32 &stn1, UINT32 &design_row, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv)

void	UpdateNormals_D (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &design_row, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv)

void	UpdateNormals_G (const UINT32 &stn1, const UINT32 &stn2, UINT32 &design_row, matrix_2d normals, matrix_2d AtVinv)

void	UpdateNormals_X (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &design_row, matrix_2d normals, matrix_2d design, matrix_2d *AtVinv)

void	UpdateNormals_Y (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &design_row, matrix_2d normals, matrix_2d AtVinv)

void	OutputLargestCorrection (std::string &formatted_msg)

void	PrepareDesignAndMsrMnsCmpMatrices (const UINT32 &block)

void	PrepareDesignAndMsrMnsCmpMatricesStage (const UINT32 &block)

void	FillDesignNormalMeasurementsMatrices (bool buildnewMatrices, const UINT32 &block, bool MT_ReverseOrCombine)

void	AddConstraintStationstoNormalsForward (const UINT32 &block)

void	AddConstraintStationstoNormalsReverse (const UINT32 &block, bool MT_ReverseOrCombine)

void	AddConstraintStationstoNormalsCombine (const UINT32 &block, bool MT_ReverseOrCombine)

void	AddConstraintStationstoNormalsSimultaneous (const UINT32 &block)

void	FormConstraintStationVarianceMatrix (const it_vUINT32 &_it_param_stn, matrix_2d &var_cart)

void	UpdateNormalsR (const UINT32 &block)

void	UpdateNormalsC (const UINT32 &block)

void	CarryStnEstimatesandVariancesReverseR (const UINT32 &nextBlock, const UINT32 &thisBlock)

void	ComputeStatistics ()

void	ComputeStatisticsOnIteration ()

void	ComputeTstatistics ()

void	UpdateMsrTstatistic (const UINT32 &block=0)

void	UpdateMsrTstatistic_D (it_vmsr_t &_it_msr)

void	UpdateMsrTstatistic_GXY (it_vmsr_t &_it_msr)

void	ComputeandPrintAdjMsrOnIteration ()

void	ComputeandPrintAdjMsrBlockOnIteration (const UINT32 &block, v_uint32_u32u32_pair msr_block, bool printHeader)

void	ComputeAdjMsrBlockOnIteration (const UINT32 &block)

void	ComputeAdjustedMsrPrecisions ()

void	ComputeChiSquareNetwork ()

void	ComputeChiSquare (const UINT32 &block)

void	ComputeChiSquareSimultaneous ()

void	ComputeChiSquarePhased (const UINT32 &block)

void	ComputeTestStat (const double &dof, double &chiUpper, double &chiLower, double &sigmaZero, UINT32 &passFail)

void	ComputeBlockTestStat (const UINT32 &block)

void	ComputeGlobalTestStat ()

void	ComputeGlobalNetStat ()

void	ComputePrecisionAdjMsrs (const UINT32 &block=0)

void	ComputePrecisionAdjMsrs_A (const UINT32 &block, const UINT32 &stn1, const UINT32 &stn2, const UINT32 &stn3, matrix_2d design, matrix_2d aposterioriVariances, UINT32 &design_row, UINT32 &precadjmsr_row)

void	ComputePrecisionAdjMsrs_D (const UINT32 &block, it_vmsr_t &_it_msr, matrix_2d design, matrix_2d aposterioriVariances, UINT32 &design_row, UINT32 &precadjmsr_row)

void	ComputePrecisionAdjMsrs_BCEKLMSVZ (const UINT32 &block, const UINT32 &stn1, const UINT32 &stn2, matrix_2d design, matrix_2d aposterioriVariances, UINT32 &design_row, UINT32 &precadjmsr_row)

void	ComputePrecisionAdjMsrs_HIJPQR (const UINT32 &block, const UINT32 &stn1, matrix_2d design, matrix_2d aposterioriVariances, UINT32 &design_row, UINT32 &precadjmsr_row)

void	ComputePrecisionAdjMsrs_GX (const UINT32 &block, it_vmsr_t &_it_msr, matrix_2d *aposterioriVariances, UINT32 &design_row, UINT32 &precadjmsr_row)

void	ComputePrecisionAdjMsrs_Y (const UINT32 &block, it_vmsr_t &_it_msr, matrix_2d *aposterioriVariances, UINT32 &design_row, UINT32 &precadjmsr_row)

void	UpdateMsrRecords (const UINT32 &block=0)

void	UpdateMsrRecord (const UINT32 &block, it_vmsr_t &_it_msr, const UINT32 &msr_row, const UINT32 &precadjmsr_row, const double &measPrec)

void	UpdateMsrRecords_D (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &msr_row, UINT32 &precadjmsr_row)

void	UpdateMsrRecords_GXY (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &msr_row, UINT32 &precadjmsr_row)

void	UpdateMsrRecordStats (it_vmsr_t &_it_msr, const double &measPrec)

void	ComputeGlobalPelzer ()

void	ComputeGlobalPelzer_D (it_vmsr_t &_it_msr, UINT32 &numMsr, double &sum)

void	ComputeGlobalPelzer_GXY (it_vmsr_t &_it_msr, UINT32 &numMsr, double &sum)

void	ComputeChiSquare_ABCEHIJKLMPQRSVZ (const it_vmsr_t &_it_msr, UINT32 &measurement_index, matrix_2d *measMinusComp)

void	ComputeChiSquare_D (it_vmsr_t &_it_msr, UINT32 &measurement_index, matrix_2d *measMinusComp)

void	ComputeChiSquare_G (const it_vmsr_t &_it_msr, UINT32 &measurement_index, matrix_2d *measMinusComp)

void	ComputeChiSquare_XY (const it_vmsr_t &_it_msr, UINT32 &measurement_index, matrix_2d *measMinusComp)

void	FormInverseVarianceMatrix (matrix_2d *vmat, bool LOWER_IS_CLEARED=false)

void	FormInverseGPSVarianceMatrix (const it_vmsr_t &_it_msr, matrix_2d *vmat)

bool	FormInverseVarianceMatrixReduced (it_vmsr_t _it_msr, matrix_2d *var_cart, const std::string &method_name)

void	PrintStatistics (bool printPelzer=true)

void	OpenOutputFileStreams ()

void	PrintOutputFileHeaderInfo ()

void	PrintCompMeasurements (const UINT32 &block, const std::string &msg="")

void	PrintCompMeasurementsAngular (const char cardinal, const double &computed, const double &correction, const it_vmsr_t &_it_msr)

void	PrintCompMeasurementsLinear (const char cardinal, const double &computed, const double &correction, const it_vmsr_t &_it_msr)

void	PrintCompMeasurements_A (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &design_row, printMeasurementsMode printMode)

void	PrintCompMeasurements_CELMS (it_vmsr_t &_it_msr, UINT32 &design_row, printMeasurementsMode printMode)

void	PrintCompMeasurements_D (it_vmsr_t &_it_msr, UINT32 &design_row, bool printIgnored=false)

void	PrintCompMeasurements_HR (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &design_row, printMeasurementsMode printMode)

void	PrintCompMeasurements_IJPQ (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &design_row, printMeasurementsMode printMode)

void	PrintCompMeasurements_BKVZ (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &design_row, printMeasurementsMode printMode)

void	PrintCompMeasurements_GXY (const UINT32 &block, it_vmsr_t &_it_msr, UINT32 &design_row, printMeasurementsMode printMode)

void	PrintCompMeasurements_YLLH (it_vmsr_t &_it_msr, UINT32 &design_row)

void	PrintMeasurementsAngular (const char cardinal, const double &measurement, const double &correction, const it_vmsr_t &_it_msr, bool printAdjMsr=true)

void	PrintMeasurementsLinear (const char cardinal, const double &measurement, const double &correction, const it_vmsr_t &_it_msr, bool printAdjMsr=true)

void	PrintMeasurementCorrection (const char cardinal, const it_vmsr_t &_it_msr)

void	PrintMeasurementDatabaseID (const it_vmsr_t &_it_msr, bool initialise_dbindex=true)

void	FormUniqueMsrList ()

void	PrintAdjMeasurementsHeader (bool printHeader, const std::string &table_heading, printMeasurementsMode printMode, UINT32 block, bool printBlocks=false)

void	PrintAdjMeasurements (v_uint32_u32u32_pair msr_block, bool printHeader)

void	PrintAdjMeasurementsAngular (const char cardinal, const it_vmsr_t &_it_msr, bool initialise_dbindex=true)

void	PrintAdjMeasurementsLinear (const char cardinal, const it_vmsr_t &_it_msr, bool initialise_dbindex=true)

void	PrintAdjGNSSAlternateUnits (it_vmsr_t &_it_msr, const uint32_uint32_pair &b_pam)

void	PrintAdjMeasurementStatistics (const char cardinal, const it_vmsr_t &_it_msr, bool initialise_dbindex=true)

void	PrintIgnoredAdjMeasurements (bool printHeader)

void	PrintAdjMeasurements_A (it_vmsr_t &_it_msr)

void	PrintAdjMeasurements_CELMS (it_vmsr_t &_it_msr)

void	PrintAdjMeasurements_D (it_vmsr_t &_it_msr)

void	PrintAdjMeasurements_HR (it_vmsr_t &_it_msr)

void	PrintAdjMeasurements_IJPQ (it_vmsr_t &_it_msr)

void	PrintAdjMeasurements_BKVZ (it_vmsr_t &_it_msr)

void	PrintAdjMeasurements_GXY (it_vmsr_t &_it_msr, const uint32_uint32_pair &b_pam)

void	PrintAdjMeasurements_YLLH (it_vmsr_t &_it_msr)

void	ReduceYLLHMeasurementsforPrinting (vmsr_t &y_msr, matrix_2d &mpositions, printMeasurementsMode print_mode)

void	PrintAdjStation (std::ostream &os, const UINT32 &block, const UINT32 &stn, const UINT32 &mat_idx, const matrix_2d stationEstimates, matrix_2d stationVariances, bool recomputeGeographicCoords, bool updateGeographicCoords, bool reapplyTypeBUncertainties)

void	PrintAdjStations (std::ostream &os, const UINT32 &block, const matrix_2d stationEstimates, matrix_2d stationVariances, bool printBlockID, bool recomputeGeographicCoords, bool updateGeographicCoords, bool printHeader, bool reapplyTypeBUncertainties)

void	PrintAdjStationsUniqueList (std::ostream &os, const v_mat_2d stationEstimates, v_mat_2d stationVariances, bool recomputeGeographicCoords, bool updateGeographicCoords, bool reapplyTypeBUncertainties)

void	PrintCorStations (std::ostream &cor_file, const UINT32 &block)

void	PrintCorStationsUniqueList (std::ostream &cor_file)

void	PrintCorStation (std::ostream &os, const UINT32 &block, const UINT32 &stn, const UINT32 &mat_idx, const matrix_2d *stationEstimates)

void	PrintPosUncertainty (std::ostream &os, const UINT32 &block, const UINT32 &stn, const UINT32 &mat_idx, const matrix_2d stationVariances, const UINT32 &map_idx=0, const vUINT32 blockStations=NULL)

void	PrintPosUncertainties (std::ostream &os, const UINT32 &block, const matrix_2d *stationVariances)

void	PrintPosUncertaintiesUniqueList (std::ostream &os, const v_mat_2d *stationVariances)

void	PrintPosUncertaintiesHeader (std::ostream &os)

void	UpdateGeographicCoordsPhased (const UINT32 &block, matrix_2d *estimatedStations)

void	UpdateGeographicCoords ()

UINT32	GetBlkMatrixElemStn1 (const UINT32 &block, const pit_vmsr_t _it_msr)

UINT32	GetBlkMatrixElemStn2 (const UINT32 &block, const pit_vmsr_t _it_msr)

UINT32	GetBlkMatrixElemStn3 (const UINT32 &block, const pit_vmsr_t _it_msr)

void	debug_BlockInformation (const UINT32 &currentBlock, const std::string &adjustment_method)

void	debug_SolutionInformation (const UINT32 &currentBlock)

void	BuildUniqueBlockStationMap ()

void	BuildSimultaneousStnAppearance ()

void	OpenStageFileStreams (const int file_count=0,...)

void	ReserveBlockMapRegions (const int file_count=0,...)

void	CloseStageFileStreams ()

void	LoadDatabaseId ()

Static Private Member Functions
static void	fillSinexExample ()

Private Attributes
CDnaDatum	datum_

CDnaProjection	projection_

double	_var_C

double	_var_F

matrix_2d	_inv_var_cart_c

matrix_2d	_inv_var_cart_f

project_settings	projectSettings_

binary_file_meta_t	bst_meta_

binary_file_meta_t	bms_meta_

vstn_t	bstBinaryRecords_

vmsr_t	bmsBinaryRecords_

vASL	vAssocStnList_

v_aml_pair	vAssocMsrList_

UINT32	bmsr_count_

UINT32	bstn_count_

UINT32	asl_count_

std::ofstream	debug_file

std::ofstream	adj_file

std::ofstream	xyz_file

UINT32	blockLargeCorr_

double	largestCorr_

UINT16	PRECISION_SEC_MSR

UINT16	PRECISION_SEC_STN

UINT16	PRECISION_MTR_MSR

UINT16	PRECISION_MTR_STN

UINT32	measurementParams_

UINT32	measurementCount_

UINT32	unknownParams_

UINT32	unknownsCount_

double	chiSquared_

double	chiSquaredStage_

double	sigmaZero_

double	sigmaZeroSqRt_

double	chiSquaredUpperLimit_

double	chiSquaredLowerLimit_

double	globalPelzerReliability_

int	degreesofFreedom_

UINT32	passFail_

double	maxCorr_

double	criticalValue_

UINT32	potentialOutlierCount_

bool	allStationsFixed_

message_bank< std::string >	iterationCorrections_

vUINT32	v_ContiguousNetList_

vsummary_t	v_statSummary_

vUINT32	v_pseudoMeasCountFwd_

vUINT32	v_measurementParams_

vUINT32	v_measurementCount_

vUINT32	v_measurementVarianceCount_

vUINT32	v_unknownParams_

vUINT32	v_unknownsCount_

vdouble	v_sigmaZero_

vdouble	v_chiSquaredUpperLimit_

vdouble	v_chiSquaredLowerLimit_

vUINT32	v_passFail_

v_uint32_uint32_map	v_blockStationsMap_

v_u32u32_uint32_pair	v_blockStationsMapUnique_

vvUINT32	v_ISL_

vvUINT32	v_JSL_

vvUINT32	v_CML_

v_uint32_u32u32_pair	v_msr_block_

vmsrtally	v_msrTally_

vmsrtally	v_stnmsrTally_

vv_stn_appear	v_paramStnAppearance_

vUINT32	v_parameterStationCount_

vvUINT32	v_parameterStationList_

type_b_uncertainty	typeBUncertaintyGlobal_

v_type_b_uncertainty	v_typeBUncertaintiesLocal_

v_type_b_method	v_typeBUncertaintyMethod_

v_uint32_uint32_pair	v_stationTypeBMap_

v_mat_2d	v_normals_

v_mat_2d	v_normalsR_

v_mat_2d	v_AtVinv_

v_mat_2d	v_design_

v_mat_2d	v_rigorousVariances_

v_mat_2d	v_measMinusComp_

v_mat_2d	v_estimatedStations_

v_mat_2d	v_originalStations_

v_mat_2d	v_rigorousStations_

v_mat_2d	v_junctionVariances_

v_mat_2d	v_junctionVariancesFwd_

v_mat_2d	v_junctionEstimatesFwd_

v_mat_2d	v_junctionEstimatesRev_

v_mat_2d	v_precAdjMsrsFull_

v_mat_2d	v_corrections_

v_mat_2d	v_correctionsR_

vmat_file_map	normals_map_

vmat_file_map	normalsR_map_

vmat_file_map	AtVinv_map_

vmat_file_map	design_map_

vmat_file_map	measMinusComp_map_

vmat_file_map	estimatedStations_map_

vmat_file_map	originalStations_map_

vmat_file_map	rigorousStations_map_

vmat_file_map	junctionVariances_map_

vmat_file_map	junctionVariancesFwd_map_

vmat_file_map	junctionEstimatesFwd_map_

vmat_file_map	junctionEstimatesRev_map_

vmat_file_map	rigorousVariances_map_

vmat_file_map	precAdjMsrs_map_

vmat_file_map	corrections_map_

vstring	v_stageFileStreams_

std::fstream	f_normals_

std::fstream	f_normalsR_

std::fstream	f_AtVinv_

std::fstream	f_design_

std::fstream	f_measMinusComp_

std::fstream	f_estimatedStations_

std::fstream	f_originalStations_

std::fstream	f_rigorousStations_

std::fstream	f_junctionVariances_

std::fstream	f_junctionVariancesFwd_

std::fstream	f_junctionEstimatesFwd_

std::fstream	f_junctionEstimatesRev_

std::fstream	f_rigorousVariances_

std::fstream	f_precAdjMsrs_

std::fstream	f_corrections_

concurrent_queue< UINT32 >	iterationQueue_

v_mat_2d	v_designR_

v_mat_2d	v_AtVinvR_

v_mat_2d	v_normalsRC_

v_mat_2d	v_measMinusCompR_

v_mat_2d	v_estimatedStationsR_

v_mat_2d	v_junctionVariancesR_

vUINT32	v_blockStationsR

v_msr_database_id_map	v_msr_db_map_

it_vdbid_t	_it_dbid

bool	databaseIDsLoaded_

std::atomic< bool >	isCancelled_

Detailed Description

Definition at line 211 of file dnaadjust.hpp.

Constructor & Destructor Documentation

◆ dna_adjust() [1/2]

dynadjust::networkadjust::dna_adjust::dna_adjust ( )

Definition at line 50 of file dnaadjust.cpp.

    : isPreparing_(false)
    , isAdjusting_(false)
    , isCombining_(false)
    , forward_(true)
    , isFirstTimeAdjustment_(true)
    , isIterationComplete_(false)
    , isAdjustmentQuestionable_(false)
    , blockCount_(1)
    , currentBlock_(0)
    , total_time_(0)
    , adjustStatus_(ADJUST_SUCCESS)
    , currentIteration_(0)
    , datum_(DEFAULT_EPSG_U)
    , bmsr_count_(0)
    , bstn_count_(0)
    , asl_count_(0)
    , measurementParams_(0)
    , measurementCount_(0)
    , unknownParams_(0)
    , unknownsCount_(0)
    , chiSquared_(0.)
    , sigmaZero_(0.)
    , sigmaZeroSqRt_(0.)
    , chiSquaredUpperLimit_(0.)
    , chiSquaredLowerLimit_(0.)
    , globalPelzerReliability_(0.)
    , degreesofFreedom_(0)
    , passFail_(test_stat_pass)
    , maxCorr_(0.)
    , criticalValue_(1.68)
    , allStationsFixed_(false)
    , databaseIDsLoaded_(false)
    , isCancelled_(false)
{
    statusMessages_.clear();
    bstBinaryRecords_.clear();
    bmsBinaryRecords_.clear();
    vAssocMsrList_.clear();
 
    debug_file.clear();
    v_pseudoMeasCountFwd_.clear();
    v_measurementParams_.clear();
    v_measurementCount_.clear();
    v_measurementVarianceCount_.clear();
    v_unknownParams_.clear();
    v_unknownsCount_.clear();
    v_sigmaZero_.clear();
    v_chiSquaredUpperLimit_.clear();
    v_chiSquaredLowerLimit_.clear();
    v_passFail_.clear();
    
    v_originalStations_.clear();
    v_design_.clear();
    v_measMinusComp_.clear();
 
    v_AtVinv_.clear();
    v_normals_.clear();
    v_estimatedStations_.clear();
    v_rigorousStations_.clear();
    v_junctionVariances_.clear();
    v_junctionVariancesFwd_.clear();
    v_junctionEstimatesFwd_.clear();
    v_junctionEstimatesRev_.clear();
    v_rigorousVariances_.clear();
    v_precAdjMsrsFull_.clear();
    v_corrections_.clear();
    v_blockStationsMap_.clear();
 
    v_parameterStationCount_.clear();
    v_parameterStationList_.clear();
 
    // multi thread (for reverse and combine passes)
    v_designR_.clear();
    v_measMinusCompR_.clear();
    v_AtVinvR_.clear();
    v_normalsR_.clear();
    v_estimatedStationsR_.clear();
    v_junctionVariancesR_.clear();
    v_normalsRC_.clear();
 
#ifdef _MSC_VER
#if (_MSC_VER < 1900)
    {
        // this function is obsolete in MS VC++ 14.0, VS2015
        // Set scientific format to print two places for the exponent
        _set_output_format(_TWO_DIGIT_EXPONENT);
    }
#endif
#endif
 
    // v_correctionsR_ is only used in phased adjustment.
    // In single thread mode, it holds rigorous corrections 
    // for last block.  In multi-thread mode, it is used
    // for in the reverse thread.
    switch (projectSettings_.a.adjust_mode)
    {
    case PhasedMode:
        v_correctionsR_.clear();
    }
}

References ADJUST_SUCCESS, adjustStatus_, allStationsFixed_, asl_count_, blockCount_, bmsBinaryRecords_, bmsr_count_, bstBinaryRecords_, bstn_count_, chiSquared_, chiSquaredLowerLimit_, chiSquaredUpperLimit_, criticalValue_, currentBlock_, currentIteration_, databaseIDsLoaded_, datum_, debug_file, DEFAULT_EPSG_U(), degreesofFreedom_, forward_, globalPelzerReliability_, isAdjusting_, isAdjustmentQuestionable_, isCancelled_, isCombining_, isFirstTimeAdjustment_, isIterationComplete_, isPreparing_, maxCorr_, measurementCount_, measurementParams_, passFail_, projectSettings_, sigmaZero_, sigmaZeroSqRt_, statusMessages_, test_stat_pass, total_time_, unknownParams_, unknownsCount_, v_AtVinv_, v_AtVinvR_, v_blockStationsMap_, v_chiSquaredLowerLimit_, v_chiSquaredUpperLimit_, v_corrections_, v_design_, v_designR_, v_estimatedStations_, v_estimatedStationsR_, v_junctionEstimatesFwd_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesFwd_, v_junctionVariancesR_, v_measMinusComp_, v_measMinusCompR_, v_measurementCount_, v_measurementParams_, v_measurementVarianceCount_, v_normals_, v_normalsR_, v_normalsRC_, v_originalStations_, v_parameterStationCount_, v_parameterStationList_, v_passFail_, v_precAdjMsrsFull_, v_pseudoMeasCountFwd_, v_rigorousStations_, v_rigorousVariances_, v_sigmaZero_, v_unknownParams_, v_unknownsCount_, and vAssocMsrList_.

Referenced by dna_adjust(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~dna_adjust()

dynadjust::networkadjust::dna_adjust::~dna_adjust ( )

virtual

Definition at line 153 of file dnaadjust.cpp.

{
    if (adjustStatus_ == ADJUST_EXCEPTION_RAISED)
    {
        try {
            debug_file.close();
        }
        catch (...) { }
 
        try {
            adj_file.close();
        }
        catch (...) { }
 
        try {
            xyz_file.close();
        }
        catch (...) { }
    }
}

References adj_file, ADJUST_EXCEPTION_RAISED, adjustStatus_, debug_file, and xyz_file.

◆ dna_adjust() [2/2]

dynadjust::networkadjust::dna_adjust::dna_adjust ( const dna_adjust & )

private

References dna_adjust().

Here is the call graph for this function:

Member Function Documentation

◆ operator=()

dna_adjust & dynadjust::networkadjust::dna_adjust::operator= ( const dna_adjust & )

private

References BackupNormals(), CarryForwardJunctions(), CarryReverseJunctions(), dna_adjust(), PrepareAdjustment(), PrepareAdjustmentBlock(), PrepareAdjustmentCombine(), PrepareAdjustmentMultiThread(), PrepareAdjustmentReverse(), ShrinkForwardMatrices(), UpdateEstimatesCombine(), UpdateEstimatesFinal(), UpdateEstimatesFinalNoCombine(), UpdateEstimatesForward(), and UpdateEstimatesReverse().

Here is the call graph for this function:

◆ ShrinkForwardMatrices()

void dynadjust::networkadjust::dna_adjust::ShrinkForwardMatrices ( const UINT32 currentBlock )

Definition at line 3969 of file dnaadjust.cpp.

{
    UINT32 pseudoMsrElemCount;
    if (!v_blockMeta_.at(currentBlock)._blockIsolated && !v_blockMeta_.at(currentBlock)._blockFirst)
    {
        pseudoMsrElemCount = static_cast<UINT32>(v_JSL_.at(currentBlock-1).size() * 3);
 
        v_measMinusComp_.at(currentBlock).shrink(pseudoMsrElemCount, 0);
        v_AtVinv_.at(currentBlock).shrink(0, pseudoMsrElemCount);
    }
}   

References v_AtVinv_, v_blockMeta_, v_JSL_, and v_measMinusComp_.

Referenced by AdjustPhasedForward(), and operator=().

Here is the caller graph for this function:

◆ CarryForwardJunctions()

void dynadjust::networkadjust::dna_adjust::CarryForwardJunctions	(	const UINT32	currentBlock,
		const UINT32	nextBlock )

Definition at line 4025 of file dnaadjust.cpp.

{
    // If required, print the stations for this block.  Geographic coordinates are updated
    // only if necessary for output
    if (projectSettings_.o._adj_stn_iteration)
    {
        adj_file_mutex.lock();
 
        if (projectSettings_.a.multi_thread)
        {   
            adj_file << std::endl << "1> Adjusted block " << thisBlock + 1;
            if (v_blockMeta_.at(thisBlock)._blockLast || v_blockMeta_.at(thisBlock)._blockIsolated)
                adj_file << " (forward, rigorous) " << std::endl;
            else
                adj_file << " (forward, in isolation) " << std::endl;
        }
 
        PrintAdjStations(adj_file, thisBlock, 
            &v_estimatedStations_.at(thisBlock), &v_normals_.at(thisBlock), 
            false, true, false, true, false);
        adj_file_mutex.unlock();
    }
 
    // Carry the estimated junction station coordinates and variances to the next block if
    // this block and the next block are both in the same network.  Thus, carry data except when:
    //  - thisBlock is a single block, or
    //  - nextBlock is a single block, or
    //  - thisBlock is the last block
    if (v_blockMeta_.at(thisBlock)._blockIsolated)
        return;
    if (v_blockMeta_.at(thisBlock)._blockLast)
        return;
    if (v_blockMeta_.at(nextBlock)._blockIsolated)
        return;
    
    // For staged adjustments, load block info for nextBlock
    if (projectSettings_.a.stage)
    {
        DeserialiseBlockFromMappedFile(nextBlock);
        RebuildNormals(nextBlock, __forward__, true, true);
    }
 
    CarryStnEstimatesandVariancesForward(thisBlock, nextBlock);
}

References __forward__, adj_file, dynadjust::networkadjust::adj_file_mutex, CarryStnEstimatesandVariancesForward(), DeserialiseBlockFromMappedFile(), PrintAdjStations(), projectSettings_, RebuildNormals(), v_blockMeta_, v_estimatedStations_, and v_normals_.

Referenced by AdjustPhasedForward(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CarryReverseJunctions()

bool dynadjust::networkadjust::dna_adjust::CarryReverseJunctions	(	const UINT32	currentBlock,
		const UINT32	nextBlock,
		bool	MT_ReverseOrCombine )

Definition at line 4772 of file dnaadjust.cpp.

{
    // Carrying of junction parameters not required for single blocks, nor 
    // if this is the first block
    if (v_blockMeta_.at(currentBlock)._blockIsolated)
        return false;
    if (v_blockMeta_.at(currentBlock)._blockFirst)
        return false;
 
    // matrices from previous block
    matrix_2d* estimatedStationsNext(&v_estimatedStations_.at(nextBlock));
    
    if (MT_ReverseOrCombine)
        estimatedStationsNext = &v_estimatedStationsR_.at(nextBlock);
    else
    {
        // Restore back up copy of normals for reverse adjustment in 
        // single thread mode
        if (!projectSettings_.a.stage)
            v_normals_.at(nextBlock) = v_normalsR_.at(nextBlock);
    }
 
    // For staged adjustments, load blocks info for nextBlock
    if (projectSettings_.a.stage)
        DeserialiseBlockFromMappedFile(nextBlock);
 
    // Next, update estimates for next block to original estimates
    *estimatedStationsNext = v_originalStations_.at(nextBlock);
    
    // For staged adjustments, rebuild design and AtVinv
    if (projectSettings_.a.stage)
        RebuildNormals(nextBlock, __reverse__, false, false);
    
    // Now, carry the estimated junction station coordinates and variances 
    // to the next block (to be used in the next loop).
    // Remember - the junction station estimates and variances of the next block
    // (obtained during the forward pass) were copied during the forward pass
    // in CarryStnEstimatesandVariancesForward(..), so no need to back-up prior
    // to carrying in reverse.
 
    // copy estimated coordinates and variances for the junction stations from
    // this block to the next block (which is nextBlock)
    CarryStnEstimatesandVariancesReverse(nextBlock, currentBlock, MT_ReverseOrCombine);
    
    AddConstraintStationstoNormalsReverse(nextBlock, MT_ReverseOrCombine);
 
    return true;
}

References __reverse__, AddConstraintStationstoNormalsReverse(), CarryStnEstimatesandVariancesReverse(), DeserialiseBlockFromMappedFile(), projectSettings_, RebuildNormals(), v_blockMeta_, v_estimatedStations_, v_estimatedStationsR_, v_normals_, v_normalsR_, and v_originalStations_.

Referenced by AdjustPhasedReverse(), AdjustPhasedReverseCombine(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareAdjustmentMultiThread()

void dynadjust::networkadjust::dna_adjust::PrepareAdjustmentMultiThread ( )

Definition at line 823 of file dnaadjust-multi.cpp.

{
    prepareAdjustmentQueue.reset_blocks_coming();
    
    boost::thread mt_prepare_thread(adjust_prepare_thread(this, boost::ref(prep_error)));
 
    // Start the forward, reverse and combine threads, which commences the
    // network adjustment
    mt_prepare_thread.join();
 
    // Were any exceptions thrown?  If so, re-throw and let
    // test stub handle the exception
    if (prep_error)
        // exception thrown in one of the combination adjustments
        boost::rethrow_exception(prep_error);
}

References dynadjust::networkadjust::prep_error, and dynadjust::networkadjust::prepareAdjustmentQueue.

Referenced by operator=(), and PrepareAdjustment().

Here is the caller graph for this function:

◆ PrepareAdjustmentBlock()

void dynadjust::networkadjust::dna_adjust::PrepareAdjustmentBlock	(	const UINT32	block,
		const UINT32	thread_id = 0 )

Definition at line 3837 of file dnaadjust.cpp.

{
 
    if (projectSettings_.a.multi_thread && projectSettings_.g.verbose > 2)
    {
        adj_file_mutex.lock();
        adj_file << thread_id << "> Preparing block " << block + 1 << "..." << std::endl;
        adj_file_mutex.unlock();
    }
 
    UINT32 i;
    it_vUINT32 _it_stn;
 
    if (projectSettings_.g.verbose > 3)
    {
        debug_file << "BLOCK " << block + 1 << " Station summary -------------------------------------------------" << std::endl;
        debug_file << "Stations: ";
        for (i=0; i<v_parameterStationList_.at(block).size(); ++i)
        {
            debug_file << v_parameterStationList_.at(block).at(i);
            if ((_it_stn = find(v_ISL_.at(block).begin(), v_ISL_.at(block).end(), v_parameterStationList_.at(block).at(i))) != v_ISL_.at(block).end())
                debug_file << "i ";
            else if ((_it_stn = find(v_JSL_.at(block).begin(), v_JSL_.at(block).end(), v_parameterStationList_.at(block).at(i))) != v_JSL_.at(block).end())
                debug_file << "j ";
            else 
                debug_file << " ";                
        }
        debug_file << " (";               
        for (i=0; i<v_parameterStationList_.at(block).size(); ++i)
        {
            if (i>0)
                    debug_file << ", ";
            debug_file << bstBinaryRecords_.at(v_parameterStationList_.at(block).at(i)).stationName;              
        }
        debug_file << ")" << std::endl << std::endl;
    }
 
    // Form Estimated Stations matrices. For phased adjustments, matrices 
    // for junction estimates and variances carried forward and reverse 
    // are also formed.  Initial geographic coordinates are computed also.
    PrepareStationandVarianceMatrices(block);
 
    // Dimension matrices for design, msr-comp, AtVinv, normals, corrections and 
    // precision of adjusted msrs.  msr-comp and AtVinv have additional elements
    // for junction station measurements.
    // Form design matrix from observation equations using AddMsrtoNormalandMeasMatrices.
    // In this case, the more 'difficult' measurement types are reduced to simpler
    // types to allow direct expression of measurements in terms of X, Y, Z.
    // For ever iteration thereafter, RecomputeMeasurements... is used
            
    // For phased adjustment, all stations in ISL and JSL are treated as parameters 
    // to be estimated.  The inclusion of all stations is required since:
    //      "as a consequence of the segmentation algorithm, many blocks 
    //      are formed where there are insufficient connections to datum 
    //      for the section as a whole or, some stations coordinates within 
    //      the section cannot be estimated from the set of measurements 
    //      making up the section."
    //                                          (Leahy, PhD thesis, p. 3.21).   
    //
    // To begin with, the number of rows in the block matrices corresponds with the ISL.  To facilitate
    // the above, rows must be added to all blocks (not including the first) so as to
    // cater for junction station estimates and variances carried forward, reverse and during the combination stage.
    // Depending on whether an "in isolation" or "rigorous" adjustment is being performed, the matrix 
    // dimensions are "grown" or "shrunk" accordingly (without altering the containing data in buffer).
 
    PrepareDesignAndMsrMnsCmpMatrices(block);
    
    // Is this a staged adjustment for which the matrix data is to be loaded from
    // existing stage files created from a previous run?    
    if (projectSettings_.a.stage && !projectSettings_.a.recreate_stage_files && bms_meta_.reduced)
    {
        // Staged adjustments only.
        // Load matrix data from existing .mtx stage files 
        // created from a previous run.
        PrepareMappedRegions(block);
        return;
    }
 
    if (!projectSettings_.a.stage)
    {
        // Back up normals.  This copy contains the contributions from all apriori measurement
        // variances, excluding parameter station variances and junction station variances
        v_normalsR_.at(block) = v_normals_.at(block);
 
        if (projectSettings_.a.multi_thread)
            v_normalsRC_.at(block).redim(
                v_normalsR_.at(block).rows(), v_normalsR_.at(block).columns());
 
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
        case PhasedMode:
            AddConstraintStationstoNormalsForward(block);
            break;
        case SimultaneousMode:
            AddConstraintStationstoNormalsSimultaneous(block);
            break;
        }
    }
    else
    {
        // Offload matrices to new .mtx stage files
 
        // Set memory mapped file region offsets for all 
        // matrices associated with this block
        SetRegionOffsets(block);
        // Purge from memory all matrices associated with this
        // block and write to disk (the memory mapped file)
        OffloadBlockToDisk(block);
 
        // A return here is needed to prevent any attempt to 
        // print v_design_, v_AtVinv_ or v_normals_ in verbose mode
        return;
    }
 
    if (projectSettings_.a.multi_thread && projectSettings_.g.verbose > 2)
    {
        adj_file_mutex.lock();
        adj_file << thread_id << "> Done." << std::endl;
        adj_file_mutex.unlock();
    }
 
    if (projectSettings_.g.verbose > 3)
    {
        debug_file << std::endl;
        debug_file << "Design " << std::scientific << std::setprecision(16) << v_design_.at(block) << std::endl;
        debug_file << "AtVinv " << std::scientific << std::setprecision(16) << v_AtVinv_.at(block) << std::endl;
        debug_file << "Normals " << std::scientific << std::setprecision(16) << v_normals_.at(block) << std::endl;
    }
}

References AddConstraintStationstoNormalsForward(), AddConstraintStationstoNormalsSimultaneous(), adj_file, dynadjust::networkadjust::adj_file_mutex, bms_meta_, bstBinaryRecords_, debug_file, OffloadBlockToDisk(), Phased_Block_1Mode, PhasedMode, PrepareDesignAndMsrMnsCmpMatrices(), PrepareMappedRegions(), PrepareStationandVarianceMatrices(), projectSettings_, SetRegionOffsets(), SimultaneousMode, v_AtVinv_, v_design_, v_ISL_, v_JSL_, v_normals_, v_normalsR_, v_normalsRC_, and v_parameterStationList_.

Referenced by operator=(), and PrepareAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareAdjustmentReverse()

bool dynadjust::networkadjust::dna_adjust::PrepareAdjustmentReverse	(	const UINT32	block,
		bool	MT_ReverseOrCombine )

Definition at line 4071 of file dnaadjust.cpp.

{
    // if this is a single block, then there is no need to perform a reverse adjustment
    if (v_blockMeta_.at(currentBlock)._blockIsolated)
    {
        if (projectSettings_.o._adj_stn_iteration)
        {
            adj_file_mutex.lock();
            adj_file << "Skipping reverse adjustment of (isolated) block " << currentBlock+1 << ".  Rigorous coordinates produced in forward pass. " << std::endl << std::endl;
            adj_file_mutex.unlock();
        }
 
        if (projectSettings_.a.stage)
            OffloadBlockToMappedFile(currentBlock);
 
        return false;
    }
 
    // If currentBlock is not the last block, then return true so that 
    // AdjustPhasedReverseCombine can proceed.  In this instance, the
    // Normals were already formed in CarryReverseEstimates
    if (!v_blockMeta_.at(currentBlock)._blockLast)
        return true;
 
    // OK. currentBlock is the last block, and this is the commencement of
    // a reverse run, so reset coordinates
    matrix_2d* estimatedStations(&v_estimatedStations_.at(currentBlock));   
 
    if (MT_ReverseOrCombine)
    {
        estimatedStations = &v_estimatedStationsR_.at(currentBlock);
    }
    else
    {
        // Restore back up copy of normals for reverse adjustment in 
        // single thread mode
        v_normals_.at(currentBlock) = v_normalsR_.at(currentBlock);
 
    }
 
    // Reset coordinates to original values
    *estimatedStations = v_originalStations_.at(currentBlock);
    
    AddConstraintStationstoNormalsReverse(currentBlock, MT_ReverseOrCombine);
 
    return true;
}

References AddConstraintStationstoNormalsReverse(), adj_file, dynadjust::networkadjust::adj_file_mutex, OffloadBlockToMappedFile(), projectSettings_, v_blockMeta_, v_estimatedStations_, v_estimatedStationsR_, v_normals_, v_normalsR_, and v_originalStations_.

Referenced by AdjustPhasedReverse(), AdjustPhasedReverseCombine(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareAdjustmentCombine()

bool dynadjust::networkadjust::dna_adjust::PrepareAdjustmentCombine	(	const UINT32	block,
		UINT32 &	pseudomsrJSLCount,
		bool	MT_ReverseOrCombine )

Definition at line 4287 of file dnaadjust.cpp.

{
    // No combination is required for:
    // - first or last blocks of a contiguous network
    // - isolated blocks
    // - phased adjustment (block 1) only
    if (!CombineRequired(currentBlock))
        return false;
    
    matrix_2d* estimatedStations(&v_estimatedStations_.at(currentBlock));
    
    if (projectSettings_.a.multi_thread)
        estimatedStations = &v_estimatedStationsR_.at(currentBlock);
 
    // Now, update normals taking contribution from the junction station estimates and variances
    // of the preceding block estimated in the forward pass
    // 
    // Grow AtVinv and measMinusComp to include JSLs as 'pseudo measurements' from forward adjustment.
    //
    // For all intermediate blocks, CarryStnEstimatesandVariancesReverse is called immediately after
    // an adjustment in the reverse direction, in which measMinusComp is grown to include msr-comp
    // values using junction estimates obtained from currentBlock+1.  Then CarryStnEstimatesandVariancesCombine
    // is called, measMinusComp is grown again to include msr-comp values using junction estimates 
    // obtained from currentBlock+1.  Hence intermediate blocks will be formed as follows:
    //   _____________
    //  |             |
    //  |   msr-comp  |
    //  |_____________|
    //  |             |
    //  |  jrev-comp  |  msr-comp values using junction estimates obtained from currentBlock+1 reverse pass
    //  |_____________|
    //  |             |
    //  |  jfwd-comp  |  msr-comp values using junction estimates obtained from currentBlock-1 forward pass
    //  |_____________|
    //
    // For the last block in a contiguous net, CarryStnEstimatesandVariancesCombine is called but measMinusComp 
    // is grown only to include msr-comp values using junction estimates obtained from currentBlock+1.  Hence,
    // the last block will be formed as follows:
    //   _____________
    //  |             |
    //  |   msr-comp  |
    //  |_____________|
    //  |             |
    //  |  jfwd-comp  |  msr-comp values using junction estimates obtained from currentBlock-1 forward pass
    //  |_____________|
    //
    // The first block does not need a combination adjustment.
 
    // Reset coordinates to originals
    *estimatedStations = v_originalStations_.at(currentBlock);
 
    // Carry junction station estimates from currentBlock-1 (obtained during forward
    // adjustment) to this block.
    CarryStnEstimatesandVariancesCombine(currentBlock-1, currentBlock, 
        pseudomsrJSLCount, MT_ReverseOrCombine);
 
    AddConstraintStationstoNormalsCombine(currentBlock, MT_ReverseOrCombine);
    
    return true;
 
}

References AddConstraintStationstoNormalsCombine(), CarryStnEstimatesandVariancesCombine(), CombineRequired(), projectSettings_, v_estimatedStations_, v_estimatedStationsR_, and v_originalStations_.

Referenced by AdjustPhasedReverseCombine(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BackupNormals()

void dynadjust::networkadjust::dna_adjust::BackupNormals	(	const UINT32	block,
		bool	MT_ReverseOrCombine )

Definition at line 4121 of file dnaadjust.cpp.

{
    // This procedure is only required if this block requires a combination
    // adjustment to produce rigorous estimates
    if (!CombineRequired(block))
        return;
 
    matrix_2d* normals(&v_normals_.at(block));
    matrix_2d* normalsCopy(&v_normalsR_.at(block));
 
    if (MT_ReverseOrCombine)
    {
        normals = &v_normalsR_.at(block);
        normalsCopy = &v_normalsRC_.at(block);
    }
 
    normalsCopy->copyelements(0, 0, normals, 0, 0,
        normals->rows(), normals->columns());
}

References dynadjust::math::matrix_2d::columns(), CombineRequired(), dynadjust::math::matrix_2d::copyelements(), dynadjust::math::matrix_2d::rows(), v_normals_, v_normalsR_, and v_normalsRC_.

Referenced by AdjustPhasedReverseCombine(), operator=(), and RebuildNormals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateEstimatesForward()

void dynadjust::networkadjust::dna_adjust::UpdateEstimatesForward ( const UINT32 block )

Definition at line 3984 of file dnaadjust.cpp.

{
    // update station coordinates with lsq-estimated corrections
    v_estimatedStations_.at(currentBlock).add(v_corrections_.at(currentBlock));
 
    // compute degrees of freedom (this is only performed once here during forward pass)
    v_statSummary_.at(currentBlock)._degreesofFreedom = 
        v_measurementParams_.at(currentBlock) + 
        (v_pseudoMeasCountFwd_.at(currentBlock) * 3) - 
        v_unknownParams_.at(currentBlock);
 
    if (v_blockMeta_.at(currentBlock)._blockLast || v_blockMeta_.at(currentBlock)._blockIsolated)
    {
        // update max correction
        if (fabs(v_corrections_.at(currentBlock).compute_maximum_value()) > fabs(maxCorr_))
            SetmaxCorr(v_corrections_.at(currentBlock).maxvalue());
        
        // update largest correction
        if (fabs(v_corrections_.at(currentBlock).maxvalue()) > fabs(largestCorr_))
        {
            largestCorr_ = v_corrections_.at(currentBlock).maxvalue();
            blockLargeCorr_ = currentBlock;
        }
 
        // Now copy 'estimated' coordinates to 'rigorous' for comparison on the next iteration
        v_rigorousStations_.at(currentBlock) = v_estimatedStations_.at(currentBlock);
        v_rigorousVariances_.at(currentBlock) = v_normals_.at(currentBlock);
 
        // Temporarily hold corrections for last block.  These corrections will be restored
        // in UpdateEstimatesFinal()
        if (!projectSettings_.a.multi_thread)
            if (v_blockMeta_.at(currentBlock)._blockLast)
                v_correctionsR_.at(currentBlock) = v_corrections_.at(currentBlock);
    }
}

References blockLargeCorr_, largestCorr_, maxCorr_, projectSettings_, SetmaxCorr(), v_blockMeta_, v_corrections_, v_correctionsR_, v_estimatedStations_, v_measurementParams_, v_normals_, v_pseudoMeasCountFwd_, v_rigorousStations_, v_rigorousVariances_, v_statSummary_, and v_unknownParams_.

Referenced by AdjustPhasedForward(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateEstimatesReverse()

void dynadjust::networkadjust::dna_adjust::UpdateEstimatesReverse	(	const UINT32	block,
		bool	MT_ReverseOrCombine )

Definition at line 4621 of file dnaadjust.cpp.

{
    matrix_2d* estimatedStations(&v_estimatedStations_.at(currentBlock));
    matrix_2d* corrections(&v_corrections_.at(currentBlock));
    matrix_2d* aposterioriVariances(&v_normals_.at(currentBlock));
 
    if (MT_ReverseOrCombine)
    {
        estimatedStations = &v_estimatedStationsR_.at(currentBlock);
        corrections = &v_correctionsR_.at(currentBlock);
        aposterioriVariances = &v_normalsR_.at(currentBlock);
    }   
 
    // update station coordinates with lsq-estimated corrections
    estimatedStations->add(*corrections);
 
    // Print the estimated stations for this block
    // At this point, all station estimates are "in isolation".  Rigorous to follow...
    if (projectSettings_.o._adj_stn_iteration)
    {
        adj_file_mutex.lock();
 
        if (projectSettings_.a.multi_thread)
        {
            adj_file << std::endl << "2> Adjusted block " << currentBlock + 1;
            if (v_blockMeta_.at(currentBlock)._blockFirst)
                adj_file << " (reverse, rigorous) " << std::endl;
            else
                adj_file << " (reverse, in isolation) " << std::endl;   
        }
        
        PrintAdjStations(adj_file, currentBlock, 
            estimatedStations, aposterioriVariances, 
            false, true, false, true, false);
        adj_file_mutex.unlock();
    }
    
}

References dynadjust::math::matrix_2d::add(), adj_file, dynadjust::networkadjust::adj_file_mutex, PrintAdjStations(), projectSettings_, v_blockMeta_, v_corrections_, v_correctionsR_, v_estimatedStations_, v_estimatedStationsR_, v_normals_, and v_normalsR_.

Referenced by AdjustPhasedReverse(), AdjustPhasedReverseCombine(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateEstimatesCombine()

void dynadjust::networkadjust::dna_adjust::UpdateEstimatesCombine	(	const UINT32	block,
		UINT32	prevJSLCount )

Definition at line 4661 of file dnaadjust.cpp.

{
    matrix_2d* estimatedStations(&v_estimatedStations_.at(currentBlock));
    matrix_2d* corrections(&v_corrections_.at(currentBlock));
    matrix_2d* AtVinv(&v_AtVinv_.at(currentBlock));
    matrix_2d* measMinusComp(&v_measMinusComp_.at(currentBlock));
 
    if (projectSettings_.a.multi_thread)
    {
        estimatedStations = &v_estimatedStationsR_.at(currentBlock);
        corrections = &v_correctionsR_.at(currentBlock);
        AtVinv = &v_AtVinvR_.at(currentBlock);
        measMinusComp = &v_measMinusCompR_.at(currentBlock);
    }   
 
    // copy estimated parameter station coordinates
    estimatedStations->add(*corrections);
 
    // Now, combination adjustment is complete, so shrink to "exclude" JSLs from 
    // the next reverse adjustment.
    AtVinv->shrink(0, pseudomsrJSLCount);
    measMinusComp->shrink(pseudomsrJSLCount, 0);
}

References dynadjust::math::matrix_2d::add(), projectSettings_, dynadjust::math::matrix_2d::shrink(), v_AtVinv_, v_AtVinvR_, v_corrections_, v_correctionsR_, v_estimatedStations_, v_estimatedStationsR_, v_measMinusComp_, and v_measMinusCompR_.

Referenced by AdjustPhasedReverseCombine(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateEstimatesFinal()

void dynadjust::networkadjust::dna_adjust::UpdateEstimatesFinal ( const UINT32 currentBlock )

Definition at line 4687 of file dnaadjust.cpp.

{
    // Is this the last block?  If so, the rigorous estimates were updated during the 
    // forward pass - copy values from v_correctionsR_.
    if (v_blockMeta_.at(currentBlock)._blockLast)
    {
        if (projectSettings_.a.multi_thread)
            return;
        if (projectSettings_.a.adjust_mode == Phased_Block_1Mode)
            return;
        v_corrections_.at(currentBlock) = v_correctionsR_.at(currentBlock);
        return;
    }
    
    matrix_2d* estimatedStations(&v_estimatedStations_.at(currentBlock));
    matrix_2d* corrections(&v_corrections_.at(currentBlock));
    matrix_2d* AtVinv(&v_AtVinv_.at(currentBlock));
    matrix_2d* measMinusComp(&v_measMinusComp_.at(currentBlock));
    matrix_2d* aposterioriVariances(&v_normals_.at(currentBlock));
 
    if (projectSettings_.a.multi_thread)
    {
        estimatedStations = &v_estimatedStationsR_.at(currentBlock);
        corrections = &v_correctionsR_.at(currentBlock);
        AtVinv = &v_AtVinvR_.at(currentBlock);
        measMinusComp = &v_measMinusCompR_.at(currentBlock);
        aposterioriVariances = &v_normalsR_.at(currentBlock);
    }   
 
    if (v_blockMeta_.at(currentBlock)._blockFirst)
    {
        // If this point is reached, rigorous adjustment is complete for a contiguous network, so
        // shrink to "exclude" JSLs from the next iteration.
        AtVinv->shrink(0, static_cast<UINT32>(v_JSL_.at(currentBlock).size() * 3));
        measMinusComp->shrink(static_cast<UINT32>(v_JSL_.at(currentBlock).size() * 3), 0);
    }
    
    // update max correction
    if (fabs(corrections->compute_maximum_value()) > fabs(maxCorr_))
        SetmaxCorr(corrections->maxvalue());
 
    // update largest correction
    if (fabs(corrections->maxvalue()) > fabs(largestCorr_))
    {
        largestCorr_ = corrections->maxvalue();
        blockLargeCorr_ = currentBlock;
    }
 
    if (projectSettings_.a.multi_thread)
    {
        v_corrections_.at(currentBlock) = v_correctionsR_.at(currentBlock);
        v_estimatedStations_.at(currentBlock) = v_estimatedStationsR_.at(currentBlock);
        v_normals_.at(currentBlock) = v_normalsR_.at(currentBlock);
    }
 
    // Now copy 'estimated' coordinates to 'rigorous' for comparison on the next iteration
    v_rigorousStations_.at(currentBlock) = *estimatedStations;
    v_rigorousVariances_.at(currentBlock) = *aposterioriVariances;
    
    // update original coordinates
    v_originalStations_.at(currentBlock) = v_rigorousStations_.at(currentBlock);
 
    // If this is the first block, return since UpdateEstimateReverse prints station
    // coordinates
    if (v_blockMeta_.at(currentBlock)._blockFirst)
        return;
 
    // print the 'rigorous' stations for this block
    if (projectSettings_.o._adj_stn_iteration)
    {
 
        adj_file_mutex.lock();
        if (projectSettings_.a.multi_thread)
            adj_file << std::endl << "3> Adjusted block " << currentBlock + 1 << " (rigorous)" << std::endl;
 
        PrintAdjStations(adj_file, currentBlock, 
            &v_rigorousStations_.at(currentBlock), &v_rigorousVariances_.at(currentBlock), 
            false, true, false, true, false);       // update coordinates
 
        adj_file_mutex.unlock();
    }
}

References adj_file, dynadjust::networkadjust::adj_file_mutex, blockLargeCorr_, dynadjust::math::matrix_2d::compute_maximum_value(), largestCorr_, maxCorr_, dynadjust::math::matrix_2d::maxvalue(), Phased_Block_1Mode, PrintAdjStations(), projectSettings_, SetmaxCorr(), dynadjust::math::matrix_2d::shrink(), v_AtVinv_, v_AtVinvR_, v_blockMeta_, v_corrections_, v_correctionsR_, v_estimatedStations_, v_estimatedStationsR_, v_JSL_, v_measMinusComp_, v_measMinusCompR_, v_normals_, v_normalsR_, v_originalStations_, v_rigorousStations_, and v_rigorousVariances_.

Referenced by AdjustPhasedReverse(), AdjustPhasedReverseCombine(), operator=(), and UpdateEstimatesFinalNoCombine().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateEstimatesFinalNoCombine()

void dynadjust::networkadjust::dna_adjust::UpdateEstimatesFinalNoCombine ( )

Definition at line 267 of file dnaadjust-multi.cpp.

{
    for (UINT32 block(0); block<blockCount_; ++block) 
        UpdateEstimatesFinal(block);
}

References blockCount_, and UpdateEstimatesFinal().

Referenced by operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GenerateStatistics()

void dynadjust::networkadjust::dna_adjust::GenerateStatistics ( )

Definition at line 7797 of file dnaadjust.cpp.

{
    // Backup the latest estimates and, if this is not a staged 
    // adjustment, update normals and measured-computed matrices.
    UpdateAdjustment(false);
 
    // Compute whole-of-network statistics.
    ComputeStatistics();
 
    // Print statistics summary to adj file
    switch (projectSettings_.a.adjust_mode)
    {
    case Phased_Block_1Mode:
        PrintStatistics(false);
        break;
    //case SimultaneousMode:
    //case PhasedMode:
    default:
        PrintStatistics();
        break;
    }
 
    isAdjustmentQuestionable_ = (
        // non zero means something is amiss
        adjustStatus_ ||
        // a much larger than expected outcome
        sigmaZero_ > 10.0 * chiSquaredUpperLimit_ ||
        // didn't converge
        fabs(maxCorr_) > projectSettings_.a.iteration_threshold);
}

References adjustStatus_, chiSquaredUpperLimit_, ComputeStatistics(), isAdjustmentQuestionable_, maxCorr_, Phased_Block_1Mode, PrintStatistics(), projectSettings_, sigmaZero_, and UpdateAdjustment().

Referenced by GenerateStatistics().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareAdjustment()

void dynadjust::networkadjust::dna_adjust::PrepareAdjustment ( const project_settings & adjustmentSettings )

Definition at line 250 of file dnaadjust.cpp.

{
    isPreparing_ = true;
    isAdjusting_ = true;
    isCombining_ = false;
    isFirstTimeAdjustment_ = true;
    projectSettings_ = projectSettings;
 
    if (projectSettings_.a.stage && 
        (projectSettings_.a.adjust_mode == SimultaneousMode || 
            projectSettings_.a.multi_thread))
        projectSettings_.a.stage = false;
 
    // Load the bst/bms meta and set the default 
    // reference frame (via binary station file)
    SetDefaultReferenceFrame();
 
    // Open output files for printing adjustment results
    OpenOutputFileStreams();
    PrintOutputFileHeaderInfo();
    
    // Initialise adjustment consts
    InitialiseAdjustment();
    
    // Load network files
    LoadNetworkFiles();
 
    // Load type b uncertainties, method handler, and the station map
    InitialiseTypeBUncertainties();
 
    isFirstTimeAdjustment_ = !bms_meta_.reduced;
 
    // Resizes matrix vectors using blockCount_.  
    // For phased adjustments, segmentation file is loaded
    ResizeMatrixVectors();
 
    if (!projectSettings_.a.report_mode)
    {
        std::string block_str(" block");
        if (blockCount_ > 1)
            block_str.append("s");
        block_str.append(")... ");
 
        adj_file << std::endl << "+ Preparing for adjustment";
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
        case PhasedMode:
            adj_file << std::left << " (" << blockCount_<< block_str;
            if (projectSettings_.a.multi_thread && projectSettings_.g.verbose > 2)
                adj_file << std::endl;
            break;
        case SimultaneousMode:
            adj_file << std::left << "... ";
        }
        adj_file.flush();
    }
    
    try {
        
        // PrepareAdjustmentMultiThread works well but fails if there 
        // is insufficient memory.  Needs a little more work to catch
        // out of memory exception.
 
#ifndef _MSDEBUG
        // Only call PrepareAdjustmentMultiThread if:
        // - not in staged adjustment mode, and
        // - not running debugger
        if (!projectSettings_.a.stage)
            PrepareAdjustmentMultiThread();
        else
#endif // #ifndef _MSDEBUG
        {
            // Prepare initial matrices for least squares adjustment
            for (UINT32 block(0); block<blockCount_; ++block)
            {
                // update block no. for progress count
                SetcurrentBlock(block);
 
                CreateMeasurementTally(block);
 
                // Prepare adjustment for this block
                PrepareAdjustmentBlock(block);
            }
        }
    }
    catch (const NetMemoryException& e) {
        std::stringstream ss;
        double memory;
        try { GetMemoryFootprint(memory, GIGABYTE_SIZE); }
        catch (...) { /*do nothing*/ }
 
        ss << "PrepareAdjustment(): Process terminated while allocating memory for the " << std::endl << "  adjustment matrices. " <<
            "Details: " << std::endl << "  " << e.what() << std::endl;
        ss << "  The memory footprint consumed by " << __BINARY_NAME__ << " is " << 
            std::fixed << std::setprecision(2) << memory << " GB" << std::endl;
        adj_file << "- Error" << std::endl << "  " << ss.str();
        SignalExceptionAdjustment(ss.str(), currentBlock_);
    }
    catch (const std::runtime_error& e) {
        std::stringstream ss;
        ss << "PrepareAdjustment(): Process terminated while preparing the " << std::endl << "  adjustment matrices. " <<
            "Details: " << std::endl << "  " << e.what() << std::endl;
        adj_file << "- Error" << std::endl << "  " << ss.str();
        SignalExceptionAdjustment(ss.str(), currentBlock_);
    }
    catch (...) {
        std::stringstream ss;
        ss << "PrepareAdjustment(): Process terminated while preparing the " << std::endl << "  adjustment matrices. " << std::endl;
        adj_file << "- Error" << std::endl << "  " << ss.str();
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    bms_meta_.reduced = true;
 
    if (projectSettings_.a.stage)
    {
        // Close binary file streams
        if (projectSettings_.a.recreate_stage_files)
            CloseStageFileStreams();
 
        // Set memory mapped file regions
        // NOTE - previously created files must exist and match the 
        // dimensions of the current matrix sizes           
        try {
            SetMapRegions();
        }
        catch (boost::interprocess::interprocess_exception& e){
            std::stringstream ss;
            ss << "PrepareMappedRegions() terminated while creating memory map" << std::endl;
            ss << "  regions from .mtx stage files. Details:\n  " << e.what() << std::endl << std::endl;
            ss << "  Please ensure the .mtx stage files from a previous staged" << std::endl;
            ss << "  adjustment exist, or re-run the adjustment using the" << std::endl;
            ss << "  --" << RECREATE_STAGE_FILES << " option." << std::endl;
            adj_file << std::endl << "- Error: " << ss.str() << std::endl;
            SignalExceptionAdjustment(ss.str(), 0);
        }
    }
 
    degreesofFreedom_ = measurementParams_ - unknownParams_;
 
    isPreparing_ = false;
 
    if (projectSettings_.a.multi_thread)
    {
        try {
            v_designR_ = v_design_;
            v_measMinusCompR_ = v_measMinusComp_;
            v_AtVinvR_ = v_AtVinv_;
            v_estimatedStationsR_ = v_estimatedStations_;
            v_junctionVariancesR_ = v_junctionVariances_;
        }
        catch (...)
        {
            std::stringstream ss;
            ss << "Failed to assign matrices for multi-thread adjustment." << std::endl;
            SignalExceptionAdjustment(ss.str(), 0);
        }
    }
 
    if (projectSettings_.a.adjust_mode == SimultaneousMode)
        BuildSimultaneousStnAppearance();
 
    BuildUniqueBlockStationMap();
 
    if (projectSettings_.o._adj_msr_final || 
        projectSettings_.o._adj_msr_iteration)
        // Create a vector of pairs (cml_id , block)
        // FormUniqueMsrList returns msr_block sorted according to block
        FormUniqueMsrList();
    
    if (projectSettings_.g.verbose > 3)
        debug_file << std::endl << std::endl;
 
    if (!projectSettings_.a.report_mode)
    {
        if (projectSettings_.a.multi_thread && projectSettings_.g.verbose > 2)
            adj_file << "+ Preparing for adjustment is";
 
        adj_file <<  " done.";
 
        if (projectSettings_.g.verbose > 0)
        {
            double memory;
            std::stringstream ss;
            try {
                GetMemoryFootprint(memory, GIGABYTE_SIZE);
                ss << std::endl << "+ The memory footprint consumed by " << __BINARY_NAME__ << " is " <<
                    std::fixed << std::setprecision(2) << memory << " GB" << std::endl;
                adj_file << ss.str();
            }
            catch (...) { /*do nothing*/ }
        }
    }
}

References adj_file, blockCount_, bms_meta_, BuildSimultaneousStnAppearance(), BuildUniqueBlockStationMap(), CloseStageFileStreams(), CreateMeasurementTally(), currentBlock_, debug_file, degreesofFreedom_, FormUniqueMsrList(), GetMemoryFootprint(), GIGABYTE_SIZE, InitialiseAdjustment(), InitialiseTypeBUncertainties(), isAdjusting_, isCombining_, isFirstTimeAdjustment_, isPreparing_, LoadNetworkFiles(), measurementParams_, OpenOutputFileStreams(), Phased_Block_1Mode, PhasedMode, PrepareAdjustmentBlock(), PrepareAdjustmentMultiThread(), PrintOutputFileHeaderInfo(), projectSettings_, RECREATE_STAGE_FILES, ResizeMatrixVectors(), SetcurrentBlock(), SetDefaultReferenceFrame(), SetMapRegions(), SignalExceptionAdjustment(), SimultaneousMode, unknownParams_, v_AtVinv_, v_AtVinvR_, v_design_, v_designR_, v_estimatedStations_, v_estimatedStationsR_, v_junctionVariances_, v_junctionVariancesR_, v_measMinusComp_, v_measMinusCompR_, and dynadjust::exception::NetMemoryException::what().

Referenced by operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CancelAdjustment()

void dynadjust::networkadjust::dna_adjust::CancelAdjustment ( )

inline

Definition at line 258 of file dnaadjust.hpp.

258{ isCancelled_.store(true); }

References isCancelled_.

◆ IsCancelled()

bool dynadjust::networkadjust::dna_adjust::IsCancelled ( ) const

inline

Definition at line 259 of file dnaadjust.hpp.

259{ return isCancelled_.load(); };

References isCancelled_.

Referenced by AdjustPhased(), AdjustPhasedForward(), AdjustPhasedMultiThread(), AdjustPhasedReverse(), AdjustPhasedReverseCombine(), AdjustSimultaneous(), UpdateAdjustment(), and ValidateandFinaliseAdjustment().

Here is the caller graph for this function:

◆ GetStatus()

_ADJUST_STATUS_ dynadjust::networkadjust::dna_adjust::GetStatus ( ) const

inline

Definition at line 261 of file dnaadjust.hpp.

261{ return adjustStatus_; }

References adjustStatus_.

Referenced by main(), and PrintSummaryMessage().

Here is the caller graph for this function:

◆ IsPreparing()

bool dynadjust::networkadjust::dna_adjust::IsPreparing ( )

inline

Definition at line 262 of file dnaadjust.hpp.

262{ return isPreparing_; }

References isPreparing_.

◆ IsAdjusting()

bool dynadjust::networkadjust::dna_adjust::IsAdjusting ( )

inline

Definition at line 263 of file dnaadjust.hpp.

263{ return isAdjusting_; }

References isAdjusting_.

◆ ExceptionRaised()

bool dynadjust::networkadjust::dna_adjust::ExceptionRaised ( )

inline

Definition at line 264 of file dnaadjust.hpp.

                                  {
        return adjustStatus_ == ADJUST_EXCEPTION_RAISED;
    }

References ADJUST_EXCEPTION_RAISED, and adjustStatus_.

◆ PrintAdjustedNetworkStations()

void dynadjust::networkadjust::dna_adjust::PrintAdjustedNetworkStations ( )

Definition at line 2372 of file dnaadjust.cpp.

{
    // print adjusted coordinates
    bool printHeader(true);
 
    switch (projectSettings_.a.adjust_mode)
    {
    case SimultaneousMode:
        PrintAdjStations(adj_file, 0, &v_estimatedStations_.at(0), &v_rigorousVariances_.at(0), false, true, true, printHeader, true);
        PrintAdjStations(xyz_file, 0, &v_estimatedStations_.at(0), &v_rigorousVariances_.at(0), false, false, false, printHeader, false);
        break;
    case PhasedMode:
    case Phased_Block_1Mode:
        // Output phased blocks as a single block?
        if (!projectSettings_.o._output_stn_blocks)
        {
            PrintAdjStationsUniqueList(adj_file,
                &v_rigorousStations_,
                &v_rigorousVariances_,
                true, true, true);
            PrintAdjStationsUniqueList(xyz_file,
                &v_rigorousStations_,
                &v_rigorousVariances_,
                true, true, false);
            return;
        }
 
        for (UINT32 block=0; block<blockCount_; ++block)
        {
            // Are phased blocks to be written to disk instead of
            // being held in memory?
            if (projectSettings_.a.stage)
            {
                DeserialiseBlockFromMappedFile(block, 2, 
                    sf_rigorous_stns, sf_rigorous_vars);
 
                if (projectSettings_.o._init_stn_corrections || projectSettings_.o._stn_corr)
                    DeserialiseBlockFromMappedFile(block, 1, 
                        sf_original_stns);
            }
 
            // adj file
            PrintAdjStations(adj_file, block,
                &v_rigorousStations_.at(block),
                &v_rigorousVariances_.at(block),
                true, true, true, printHeader, true);
            // xyz file
            PrintAdjStations(xyz_file, block,
                &v_rigorousStations_.at(block),
                &v_rigorousVariances_.at(block),
                true, false, false, printHeader, false);
 
            printHeader = false;
 
            // Release block from memory
            if (projectSettings_.a.stage)
            {
                UnloadBlock(block, 2, sf_rigorous_stns, sf_rigorous_vars);
 
                // Were original station estimates updated?  If so, serialise, otherwise unload
                if (projectSettings_.o._init_stn_corrections || projectSettings_.o._stn_corr)
                    SerialiseBlockToMappedFile(block, 1,
                        sf_original_stns);
            }
 
            // Exit if block-1 mode
            if (projectSettings_.a.adjust_mode == Phased_Block_1Mode)
                break;
        }
        break;
    }
}

References adj_file, blockCount_, DeserialiseBlockFromMappedFile(), Phased_Block_1Mode, PhasedMode, PrintAdjStations(), PrintAdjStationsUniqueList(), projectSettings_, SerialiseBlockToMappedFile(), sf_original_stns, sf_rigorous_stns, sf_rigorous_vars, SimultaneousMode, UnloadBlock(), v_estimatedStations_, v_rigorousStations_, v_rigorousVariances_, and xyz_file.

Referenced by PrintAdjustedNetworkStations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintPositionalUncertainty()

void dynadjust::networkadjust::dna_adjust::PrintPositionalUncertainty ( )

Definition at line 2516 of file dnaadjust.cpp.

{
    std::ofstream apu_file;
    try {
        // Create apu file.  Throws runtime_error on failure.
        file_opener(apu_file, projectSettings_.o._apu_file);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    // Print formatted header
    print_file_header(apu_file, "DYNADJUST POSITIONAL UNCERTAINTY OUTPUT FILE");
    
    apu_file << std::setw(PRINT_VAR_PAD) << std::left << "File name:" << boost::filesystem::system_complete(projectSettings_.o._apu_file).string() << std::endl << std::endl;
    
    apu_file << std::setw(PRINT_VAR_PAD) << std::left << "PU confidence interval:" << std::setprecision(1) << std::fixed << 
        // projectSettings_.a.confidence_interval << "%" << std::endl;
        // the SP1 standard for PU is 95% and the formula is designed to achieve that end,
        // irrespective of the adjustment confidence interval
        95.0 << "%" << std::endl;   
        
    apu_file << std::setw(PRINT_VAR_PAD) << std::left << "Error ellipse axes:" << std::setprecision(1) << std::fixed <<
        68.3 << "% (1 sigma)" << std::endl;
 
    apu_file << std::setw(PRINT_VAR_PAD) << std::left << "Variances:" << std::setprecision(1) << std::fixed <<
        68.3 << "% (1 sigma)" << std::endl;
    
    apu_file << std::setw(PRINT_VAR_PAD) << std::left << "Stations printed in blocks:";
    if (projectSettings_.a.adjust_mode != SimultaneousMode)
    {
        if (projectSettings_.o._output_stn_blocks)
            apu_file << "Yes" << std::endl;
        else
        {
            if (projectSettings_.o._output_pu_covariances)
                apu_file << std::left << "Yes (enforced with output-all-covariances)" << std::endl;
            else
                apu_file << std::left << "No" << std::endl;
        }
    }
    else
        apu_file << std::left << "No" << std::endl;
 
    apu_file << std::setw(PRINT_VAR_PAD) << std::left << "Variance matrix units:";
    switch (projectSettings_.o._apu_vcv_units)
    {
    case ENU_apu_ui:
        apu_file << std::left << "ENU" << std::endl;
        break;
    default:
    case XYZ_apu_ui:
        apu_file << std::left << "XYZ" << std::endl;
        break;
    }
 
    apu_file <<
        std::setw(PRINT_VAR_PAD) << std::left << "Full covariance matrix:";
    if (projectSettings_.o._output_pu_covariances)
        apu_file << std::left << "Yes" << std::endl;
    else
        apu_file << std::left << "No" << std::endl;
 
    if (projectSettings_.o._apply_type_b_file || projectSettings_.o._apply_type_b_global)
    {
        if (projectSettings_.o._apply_type_b_global)
            apu_file << std::setw(PRINT_VAR_PAD) << std::left << "Type B uncertainties:" <<
                projectSettings_.a.type_b_global << std::endl;
 
        if (projectSettings_.o._apply_type_b_file)
            apu_file << std::setw(PRINT_VAR_PAD) << std::left << "Type B uncertainty file:" <<
                boost::filesystem::system_complete(projectSettings_.a.type_b_file).string() << std::endl;
    }
 
    apu_file << OUTPUTLINE << std::endl << std::endl;
 
    apu_file << "Positional uncertainty of adjusted station coordinates" << std::endl;
    apu_file << "------------------------------------------------------" << std::endl;
    
    apu_file << std::endl;
 
    switch (projectSettings_.a.adjust_mode)
    {
    case SimultaneousMode:
        PrintPosUncertainties(apu_file, 0, 
            &v_rigorousVariances_.at(0));
        break;
    case PhasedMode:
        // Output phased blocks as a single block?
        if (!projectSettings_.o._output_stn_blocks &&       // Print stations in blocks?
            !projectSettings_.o._output_pu_covariances)     // Print covariances?
                                                            // If covariances are required, stations
                                                            // must be printed in blocks.
        {
            PrintPosUncertaintiesUniqueList(apu_file, 
                &v_rigorousVariances_);
            return;
        }
 
        for (UINT32 block=0; block<blockCount_; ++block)
        {
            // load up this block
            if (projectSettings_.a.stage)
                DeserialiseBlockFromMappedFile(block, 1, 
                    sf_rigorous_vars);
 
            PrintPosUncertainties(apu_file, block, 
                &v_rigorousVariances_.at(block));
 
            // unload this block
            if (projectSettings_.a.stage)
                UnloadBlock(block, 1, 
                    sf_rigorous_vars);
        }
        break;
    case Phased_Block_1Mode:      // only the first block is rigorous
        PrintPosUncertainties(apu_file, 0, 
            &v_rigorousVariances_.at(0));
        break;
    }
 
    apu_file.close();
}

References blockCount_, DeserialiseBlockFromMappedFile(), ENU_apu_ui, file_opener(), OUTPUTLINE, Phased_Block_1Mode, PhasedMode, print_file_header(), PRINT_VAR_PAD(), PrintPosUncertainties(), PrintPosUncertaintiesUniqueList(), projectSettings_, sf_rigorous_vars, SignalExceptionAdjustment(), SimultaneousMode, UnloadBlock(), v_rigorousVariances_, and XYZ_apu_ui.

Referenced by PrintPositionalUncertainty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintNetworkStationCorrections()

void dynadjust::networkadjust::dna_adjust::PrintNetworkStationCorrections ( )

Definition at line 2642 of file dnaadjust.cpp.

{
    std::ofstream cor_file;
    try {
        // Create cor file.  Throws runtime_error on failure.
        file_opener(cor_file, projectSettings_.o._cor_file);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    // Print formatted header
    print_file_header(cor_file, "DYNADJUST CORRECTIONS OUTPUT FILE");
    cor_file << std::setw(PRINT_VAR_PAD) << std::left << "File name:" << boost::filesystem::system_complete(projectSettings_.o._cor_file).string() << std::endl << std::endl;
 
    cor_file << std::setw(PRINT_VAR_PAD) << std::left << "Stations printed in blocks:";
    if (projectSettings_.a.adjust_mode != SimultaneousMode &&
        projectSettings_.o._output_stn_blocks)
            cor_file << "Yes" << std::endl << std::endl;
    else
        cor_file << "No" << std::endl;
    cor_file << OUTPUTLINE << std::endl << std::endl;
 
    cor_file << "Corrections to stations" << std::endl;
    cor_file << "------------------------------------------" << std::endl << std::endl;
 
    switch (projectSettings_.a.adjust_mode)
    {
    case SimultaneousMode:
        PrintCorStations(cor_file, 0);
        break;
    case PhasedMode:
        // Output phased blocks as a single block?
        if (!projectSettings_.o._output_stn_blocks)
        {
            PrintCorStationsUniqueList(cor_file);
            return;
        }
 
        for (UINT32 block=0; block<blockCount_; ++block)
        {
            // load up this block
            if (projectSettings_.a.stage)
                DeserialiseBlockFromMappedFile(block, 2,
                    sf_rigorous_stns, sf_original_stns);
 
            PrintCorStations(cor_file, block);
 
            // unload previous block
            if (projectSettings_.a.stage)
                UnloadBlock(block, 2, 
                    sf_rigorous_stns, sf_original_stns);
        }
        break;
    case Phased_Block_1Mode:      // only the first block is rigorous
        PrintCorStations(cor_file, 0);
        break;
    }
    
    cor_file.close();
}

References blockCount_, DeserialiseBlockFromMappedFile(), file_opener(), OUTPUTLINE, Phased_Block_1Mode, PhasedMode, print_file_header(), PRINT_VAR_PAD(), PrintCorStations(), PrintCorStationsUniqueList(), projectSettings_, sf_original_stns, sf_rigorous_stns, SignalExceptionAdjustment(), SimultaneousMode, and UnloadBlock().

Referenced by PrintStationCorrections().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjustedNetworkMeasurements()

void dynadjust::networkadjust::dna_adjust::PrintAdjustedNetworkMeasurements ( )

Definition at line 3202 of file dnaadjust.cpp.

{
    if (adjustStatus_ > ADJUST_TEST_FAILED)
        return;
    
    bool printHeader(true);
 
    if (projectSettings_.o._database_ids)
        if (!databaseIDsLoaded_ || v_msr_db_map_.empty())
            LoadDatabaseId();
 
    _it_uint32_u32u32_pair begin, end;
 
    switch (projectSettings_.a.adjust_mode)
    {
    case Phased_Block_1Mode:  // only the first block is rigorous
        begin = v_msr_block_.begin();
        end = begin + v_CML_.at(0).size();
        PrintAdjMeasurements(v_uint32_u32u32_pair(begin, end), printHeader);
        break;
    case SimultaneousMode:
        PrintAdjMeasurements(v_msr_block_, printHeader);
        break;
    case PhasedMode:
        if (projectSettings_.o._output_msr_blocks)
        {
            begin = v_msr_block_.begin();
            
            for (UINT32 block=0; block<blockCount_; ++block)
            {
                // send subvector of measurements from this block
                end = begin + v_CML_.at(block).size();
                
                PrintAdjMeasurements(v_uint32_u32u32_pair(begin, end), printHeader);
                begin = end;
                printHeader = false;
            }
        }
        else
        {
            PrintAdjMeasurements(v_msr_block_, printHeader);
        }
    }
 
    switch (projectSettings_.a.adjust_mode)
    {
    case PhasedMode:
    case SimultaneousMode:
        if (projectSettings_.o._print_ignored_msrs)
            // Print comparison between ignored and computed 
            // measurements from adjusted coordinates
            PrintIgnoredAdjMeasurements(true);       
        break;
    }
}

References ADJUST_TEST_FAILED, adjustStatus_, blockCount_, databaseIDsLoaded_, LoadDatabaseId(), Phased_Block_1Mode, PhasedMode, PrintAdjMeasurements(), PrintIgnoredAdjMeasurements(), projectSettings_, SimultaneousMode, v_CML_, v_msr_block_, and v_msr_db_map_.

Referenced by PrintAdjustedMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintMeasurementsToStation()

void dynadjust::networkadjust::dna_adjust::PrintMeasurementsToStation ( )

Definition at line 3297 of file dnaadjust.cpp.

{
    // Create Measurement tally.  Loads up the AML file.
    CreateMsrToStnTally();
 
    // Print measurement to station summary header
    std::string header("Measurements to Station ");
    MsrToStnSummaryHeader(adj_file, header);
 
    _it_vmsrtally it_vstnmsrs;
 
    vUINT32 vStationList(bstBinaryRecords_.size());
    it_vUINT32 _it_stn(vStationList.begin());
 
    // initialise vector with 0,1,2,...,n-2,n-1,n
    initialiseIncrementingIntegerVector<UINT32>(vStationList, static_cast<UINT32>(bstBinaryRecords_.size()));
    
    // Print measurement to station summary, sort stations as required
    switch (projectSettings_.o._sort_msr_to_stn)
    {
    case meas_stn_sort_ui:
    {
        // sort summary according to measurement to station count
        CompareMeasCount<CAStationList, UINT32> msrcountCompareFunc(&vAssocStnList_);
        std::sort(vStationList.begin(), vStationList.end(), msrcountCompareFunc);
    }
    break;
    case orig_stn_sort_ui:
    default:
    {
        // sort summary according to original station file order
        CompareStnFileOrder<station_t, UINT32> stnorderCompareFunc(&bstBinaryRecords_);
        std::sort(vStationList.begin(), vStationList.end(), stnorderCompareFunc);
    }
    break;
    }
 
    // Print measurements to each station and the total count for each station
    for (_it_stn=vStationList.begin(); _it_stn != vStationList.end(); ++_it_stn)
        v_stnmsrTally_.at(*_it_stn).coutSummaryMsrToStn(adj_file, bstBinaryRecords_.at(*_it_stn).stationName);
    
    // Print "the bottom line"
    MsrToStnSummaryHeaderLine(adj_file);
 
    // Print the total count per measurement
    MsrTally msrTally;
    for (it_vstnmsrs=v_stnmsrTally_.begin(); it_vstnmsrs!=v_stnmsrTally_.end(); ++it_vstnmsrs)
        msrTally += *it_vstnmsrs;
    
    msrTally.coutSummaryMsrToStn(adj_file, "Totals");
    
    adj_file << std::endl << std::endl;
}

References adj_file, bstBinaryRecords_, dynadjust::measurements::MsrTally::coutSummaryMsrToStn(), CreateMsrToStnTally(), initialiseIncrementingIntegerVector(), meas_stn_sort_ui, dynadjust::measurements::MsrToStnSummaryHeader(), dynadjust::measurements::MsrToStnSummaryHeaderLine(), orig_stn_sort_ui, projectSettings_, v_stnmsrTally_, and vAssocStnList_.

Referenced by PrintMeasurementstoStations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintEstimatedStationCoordinatestoSNX()

bool dynadjust::networkadjust::dna_adjust::PrintEstimatedStationCoordinatestoSNX ( std::string & sinex_file )

Definition at line 2704 of file dnaadjust.cpp.

{
    std::ofstream sinex_file;
    std::string sinexFilename;
    std::string sinexBasename = projectSettings_.g.output_folder + FOLDER_SLASH + projectSettings_.g.network_name;
    std::stringstream ssBlock;
 
    matrix_2d *estimates = nullptr, *variances = nullptr;
 
    bool success(true);
 
    // Print a sinex file for each block
    for (UINT32 block(0); block<blockCount_; ++block)
    {
        sinexFilename = sinexBasename;
 
        // Add block number for phased adjustments
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
            if (block > 0)
            {
                block = blockCount_;
                continue;
            }
            [[fallthrough]];
        case PhasedMode:
            ssBlock.str("");
            ssBlock << "-block" << block + 1;
            sinexFilename += ssBlock.str();
 
            // if staged, load up the block from memory mapped files
            if (projectSettings_.a.stage)
                DeserialiseBlockFromMappedFile(block, 2, 
                    sf_rigorous_stns, sf_rigorous_vars);
 
            estimates = &v_rigorousStations_.at(block);
            variances = &v_rigorousVariances_.at(block);
            break;
        case SimultaneousMode:
            estimates = &v_estimatedStations_.at(block);
            variances = &v_normals_.at(block);
        }
 
        // add reference frame to file name
        sinexFilename += "." + projectSettings_.r.reference_frame;      
 
        // add conventional file extension
        sinexFilename += ".snx";
 
        if (block < 1)
            sinex_filename = sinexFilename;
        
        try {
            // Open output file stream.  Throws runtime_error on failure.
            file_opener(sinex_file, sinexFilename);
        }
        catch (const std::runtime_error& e) {
            SignalExceptionAdjustment(e.what(), 0);
        }
 
        dna_io_snx snx;
 
        try {
            // Print results for adjustment in SINEX format.
            // Throws runtime_error on failure.
            snx.serialise_sinex(&sinex_file, &bstBinaryRecords_,
                bst_meta_, bms_meta_, estimates, variances, projectSettings_,
                measurementParams_, unknownsCount_, sigmaZero_,
                &v_blockStationsMap_.at(block), &v_parameterStationList_.at(block),
                blockCount_, block,
                &datum_);
        }
        catch (const std::runtime_error& e) {
            SignalExceptionAdjustment(e.what(), 0);
        }
 
        if (projectSettings_.a.adjust_mode == PhasedMode)
            // if staged, unload the block
            if (projectSettings_.a.stage)
                UnloadBlock(block, 2, 
                    sf_rigorous_stns, sf_rigorous_vars);
 
        sinex_file.close();
 
        if (!snx.warnings_exist())
            continue;
 
        success = false;
 
        sinexFilename += ".err";
        try {
            // Open output file stream.  Throws runtime_error on failure.
            file_opener(sinex_file, sinexFilename);
        }
        catch (const std::runtime_error& e) {
            SignalExceptionAdjustment(e.what(), 0);
        }
 
        snx.print_warnings(&sinex_file, sinexFilename);
        sinex_file.close();     
    }
 
    return success;
}

References blockCount_, bms_meta_, bst_meta_, bstBinaryRecords_, datum_, DeserialiseBlockFromMappedFile(), file_opener(), measurementParams_, Phased_Block_1Mode, PhasedMode, dynadjust::iostreams::dna_io_snx::print_warnings(), projectSettings_, dynadjust::iostreams::dna_io_snx::serialise_sinex(), sf_rigorous_stns, sf_rigorous_vars, sigmaZero_, SignalExceptionAdjustment(), SimultaneousMode, unknownsCount_, UnloadBlock(), v_blockStationsMap_, v_estimatedStations_, v_normals_, v_parameterStationList_, v_rigorousStations_, v_rigorousVariances_, and dynadjust::iostreams::dna_io_snx::warnings_exist().

Referenced by ExportSinex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintEstimatedStationCoordinatestoDNAXML()

void dynadjust::networkadjust::dna_adjust::PrintEstimatedStationCoordinatestoDNAXML	(	const std::string &	stnFile,
		INPUT_FILE_TYPE	t,
		bool	flagUnused = false )

Definition at line 2981 of file dnaadjust.cpp.

{
    // Stations
    std::ofstream stn_file;
    try {
        // Create STN/XML file. 
        file_opener(stn_file, stnFile);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    try {
    
        UINT32 count(static_cast<UINT32>(bstBinaryRecords_.size()));
        dna_stn_fields dsl, dsw;
 
        std::string headerComment("Source data:  Coordinates estimated from least squares adjustment.");
        
        // print header
        switch (t)
        {
        case dynaml:
 
            // Write header and comments
            dynaml_header(stn_file, "Station File", datum_.GetName(), datum_.GetEpoch_s());
            dynaml_comment(stn_file, "File type:    Station file");
            dynaml_comment(stn_file, "Project name: " + projectSettings_.g.network_name);
            dynaml_comment(stn_file, headerComment);
            dynaml_comment(stn_file, "Adj file:     " + projectSettings_.o._adj_file);
            break;
 
        case dna:
 
            // get file format field widths
            determineDNASTNFieldParameters<UINT16>("3.01", dsl, dsw);
 
            // Write header and comments
            dna_header(stn_file, "3.01", "STN", datum_.GetName(), datum_.GetEpoch_s(), count);
            dna_comment(stn_file, "File type:    Station file");
            dna_comment(stn_file, "Project name: " + projectSettings_.g.network_name);
            dna_comment(stn_file, headerComment);
            dna_comment(stn_file, "Adj file:     " + projectSettings_.o._adj_file);
            break;
        default:
            break;
        }
 
        dnaStnPtr stnPtr(new CDnaStation(datum_.GetName(), datum_.GetEpoch_s()));
 
        vUINT32 vStationList;
 
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
            // Get stations in block 1 only
            vStationList = v_parameterStationList_.at(0);
            break;
        default:
            // Create and initialise vector with 0,1,2,...,n-2,n-1,n for
            // all stations in the network
            vStationList.resize(bstBinaryRecords_.size());
            initialiseIncrementingIntegerVector<UINT32>(vStationList, static_cast<UINT32>(bstBinaryRecords_.size()));
        }
        
        // Sort on original file order
        CompareStnFileOrder<station_t, UINT32> stnorderCompareFunc(&bstBinaryRecords_);
        std::sort(vStationList.begin(), vStationList.end(), stnorderCompareFunc);
 
        // print station coordinates
        switch (t)
        {
        case dynaml:
 
            if (flagUnused)
                // Print stations in DynaML format
                for_each(vStationList.begin(), vStationList.end(),
                    [&stn_file, &stnPtr, this](const UINT32& stn) {
                        stnPtr->SetStationRec(bstBinaryRecords_.at(stn));
                        if (stnPtr->IsNotUnused())
                            stnPtr->WriteDNAXMLStnCurrentEstimates(&stn_file,
                                datum_.GetEllipsoidRef(), &projection_, dynaml);
                });
            else
                // Print stations in DynaML format
                for_each(vStationList.begin(), vStationList.end(),
                    [&stn_file, &stnPtr, this](const UINT32& stn) {
                        stnPtr->SetStationRec(bstBinaryRecords_.at(stn));
                        stnPtr->WriteDNAXMLStnCurrentEstimates(&stn_file,
                            datum_.GetEllipsoidRef(), &projection_, dynaml);
                });
 
            stn_file << "</DnaXmlFormat>" << std::endl;
 
            break;
        case dna:
 
            if (flagUnused)
                // Print stations in DNA format
                for_each(vStationList.begin(), vStationList.end(),
                    [&stn_file, &stnPtr, &dsw, this](const UINT32& stn) {
                        stnPtr->SetStationRec(bstBinaryRecords_.at(stn));
                        if (stnPtr->IsNotUnused())
                            stnPtr->WriteDNAXMLStnCurrentEstimates(&stn_file, 
                                datum_.GetEllipsoidRef(), &projection_, dna, &dsw);
                });
            else
                // Print stations in DNA format
                for_each(vStationList.begin(), vStationList.end(),
                    [&stn_file, &stnPtr, &dsw, this](const UINT32& stn) {
                        stnPtr->SetStationRec(bstBinaryRecords_.at(stn));
                        stnPtr->WriteDNAXMLStnCurrentEstimates(&stn_file,
                            datum_.GetEllipsoidRef(), &projection_, dna, &dsw);
                });
 
            break;
        default:
            break;
        }
 
 
        stn_file.close();
    }
    catch (const std::ofstream::failure& f) {
        SignalExceptionAdjustment(f.what(), 0);
    }
    catch (const XMLInteropException& e)  {
        SignalExceptionAdjustment(e.what(), 0);
    }
}

References bstBinaryRecords_, datum_, determineDNASTNFieldParameters(), dna, dna_comment(), dna_header(), dynaml, dynaml_comment(), dynaml_header(), file_opener(), initialiseIncrementingIntegerVector(), Phased_Block_1Mode, projectSettings_, SignalExceptionAdjustment(), and v_parameterStationList_.

Referenced by ExportDNA(), and ExportDynaML().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintEstimatedStationCoordinatestoDNAXML_Y()

void dynadjust::networkadjust::dna_adjust::PrintEstimatedStationCoordinatestoDNAXML_Y	(	const std::string &	msrFile,
		INPUT_FILE_TYPE	t )

Definition at line 2810 of file dnaadjust.cpp.

{
    // Measurements
    std::ofstream msr_file;
    try {
        // Create STN/XML file. 
        file_opener(msr_file, msrFile);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    dna_msr_fields dml, dmw;
 
    std::stringstream ss;
 
    try {
    
        UINT32 count(static_cast<UINT32>(v_blockStationsMapUnique_.size()));
        ss << "Source data:  Coordinates and uncertainties for " << 
            count << " unique stations in " << blockCount_ << " blocks " <<
            "estimated from least squares adjustment.";
        std::string headerComment(ss.str());
        
        // print header
        switch (t)
        {
        case dynaml:
 
            // Write header and comments
            dynaml_header(msr_file, "Measurement File", datum_.GetName(), datum_.GetEpoch_s());
            dynaml_comment(msr_file, "File type:    Measurement file");
            dynaml_comment(msr_file, "Project name: " + projectSettings_.g.network_name);
            dynaml_comment(msr_file, headerComment);
            dynaml_comment(msr_file, "Adj file:     " + projectSettings_.o._adj_file);
            break;
 
        case dna:
 
            // get file format field widths
            determineDNAMSRFieldParameters<UINT16>("3.01", dml, dmw);
 
            // Write header and comments
            dna_header(msr_file, "3.01", "MSR", datum_.GetName(), datum_.GetEpoch_s(), blockCount_);
            dna_comment(msr_file, "File type:    Measurement file");
            dna_comment(msr_file, "Project name: " + projectSettings_.g.network_name);
            dna_comment(msr_file, headerComment);
            dna_comment(msr_file, "Adj file:     " + projectSettings_.o._adj_file);
            break;
        default:
            break;
        }
    }
    catch (const std::ofstream::failure& f) {
        SignalExceptionAdjustment(f.what(), 0);
    }
    catch (const XMLInteropException& e)  {
        SignalExceptionAdjustment(e.what(), 0);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    try
    {   
        matrix_2d *estimates = nullptr, *variances = nullptr;
        dnaMsrPtr msr_ptr;
        std::string comment;
 
        // Create a Y cluster for each block
        for (UINT32 block(0); block<blockCount_; ++block)
        {
            // Get the appropriate coordinate and uncertainty estimates
            switch (projectSettings_.a.adjust_mode)
            {
            case Phased_Block_1Mode:
                if (block > 0)
                {
                    block = blockCount_;
                    continue;
                }
                [[fallthrough]];
            case PhasedMode:
                
                // if staged, load up the block from memory mapped files
                if (projectSettings_.a.stage)
                    DeserialiseBlockFromMappedFile(block, 2, 
                        sf_rigorous_stns, sf_rigorous_vars);
 
                estimates = &v_rigorousStations_.at(block);
                variances = &v_rigorousVariances_.at(block);
                break;
            case SimultaneousMode:
                estimates = &v_estimatedStations_.at(block);
                variances = &v_normals_.at(block);
            }
 
            msr_ptr.reset(new CDnaGpsPointCluster(block, datum_.GetName(), datum_.GetEpoch_s()));
            msr_ptr.get()->PopulateMsr(&bstBinaryRecords_, 
                &v_blockStationsMap_.at(block), &v_parameterStationList_.at(block), 
                block, &datum_, estimates, variances);
 
            if (projectSettings_.a.adjust_mode == PhasedMode)
                // if staged, unload the block
                if (projectSettings_.a.stage)
                    UnloadBlock(block, 2, 
                        sf_rigorous_stns, sf_rigorous_vars);
 
            ss.str("");
 
            // print station coordinate estimates as a GNSS Y cluster
            switch (t)
            {
            case dynaml:
                ss << std::endl <<
                    "    - Estimated station coordinates and uncertainties";
                if (blockCount_ > 1)
                    ss << " for block " << (block + 1);
                ss << std::endl <<
                    "    - Type (Y) GPS point cluster (set of " << v_blockStationsMap_.at(block).size() << " stations)";
                if (blockCount_ > 1)
                {
                    ss << ":" << std::endl <<
                        "      - " << v_ISL_.at(block).size() << " inner station";
                    if (v_ISL_.at(block).size() != 1)
                        ss << "s";
                    ss << std::endl <<
                        "      - " << v_JSL_.at(block).size() << " junction station";
                    if (v_JSL_.at(block).size() != 1)
                        ss << "s";
                    ss << std::endl;
                }
                else
                    ss << std::endl;
 
                ss << " ";
                comment = ss.str();
                // Print station coordinate estimates in DynaML format
                msr_ptr.get()->WriteDynaMLMsr(&msr_file, comment);
                break;
            case dna:
                // Print station coordinate estimates in DNA format
                msr_ptr.get()->WriteDNAMsr(&msr_file, dmw, dml);
                break;
            default:
                break;
            }
        }
 
        switch (t)
        {
        case dynaml:
            msr_file << "</DnaXmlFormat>" << std::endl;
            break;
        case dna:
        default:
            break;
        }
 
        msr_file.close();
    }
    catch (const std::ofstream::failure& f) {
        SignalExceptionAdjustment(f.what(), 0);
    }
    catch (const XMLInteropException& e)  {
        SignalExceptionAdjustment(e.what(), 0);
    }
}

References blockCount_, bstBinaryRecords_, datum_, DeserialiseBlockFromMappedFile(), determineDNAMSRFieldParameters(), dna, dna_comment(), dna_header(), dynaml, dynaml_comment(), dynaml_header(), file_opener(), Phased_Block_1Mode, PhasedMode, projectSettings_, sf_rigorous_stns, sf_rigorous_vars, SignalExceptionAdjustment(), SimultaneousMode, UnloadBlock(), v_blockStationsMap_, v_blockStationsMapUnique_, v_estimatedStations_, v_ISL_, v_JSL_, v_normals_, v_parameterStationList_, v_rigorousStations_, and v_rigorousVariances_.

Referenced by ExportDNA(), and ExportDynaML().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CloseOutputFiles()

void dynadjust::networkadjust::dna_adjust::CloseOutputFiles ( )

Definition at line 3352 of file dnaadjust.cpp.

{
    adj_file.close();
    xyz_file.close();
 
    if (projectSettings_.g.verbose > 0)
        debug_file.close();
}

References adj_file, debug_file, projectSettings_, and xyz_file.

Referenced by main().

Here is the caller graph for this function:

◆ UpdateBinaryFiles()

void dynadjust::networkadjust::dna_adjust::UpdateBinaryFiles ( )

Definition at line 447 of file dnaadjust.cpp.

{
    snprintf(bst_meta_.modifiedBy, sizeof(bst_meta_.modifiedBy), "%s", __BINARY_NAME__);
    bst_meta_.reduced = true;
 
    try {
        // Write binary stations data.  Throws runtime_error on failure.
        dna_io_bst bst;
        bst.write_bst_file(projectSettings_.a.bst_file, &bstBinaryRecords_, bst_meta_);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    snprintf(bms_meta_.modifiedBy, sizeof(bms_meta_.modifiedBy), "%s", __BINARY_NAME__);
    bms_meta_.reduced = true;
 
    try {
        // Write binary measurements data.  Throws runtime_error on failure.
        dna_io_bms bms;
        bms.write_bms_file(projectSettings_.a.bms_file, &bmsBinaryRecords_, bms_meta_);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }   
}

References bms_meta_, bmsBinaryRecords_, bst_meta_, bstBinaryRecords_, projectSettings_, SignalExceptionAdjustment(), dynadjust::iostreams::dna_io_bms::write_bms_file(), and dynadjust::iostreams::dna_io_bst::write_bst_file().

Referenced by UpdateBinaryFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CurrentIteration()

UINT32 dynadjust::networkadjust::dna_adjust::CurrentIteration ( ) const

Definition at line 175 of file dnaadjust.cpp.

{ 
    boost::lock_guard<boost::mutex> lock(current_iterationMutex);
    return currentIteration_; 
}

References dynadjust::networkadjust::current_iterationMutex, and currentIteration_.

Referenced by AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), PrintAdjMeasurements(), PrintAdjustmentStatus(), PrintSummaryMessage(), and ValidateandFinaliseAdjustment().

Here is the caller graph for this function:

◆ incrementIteration()

UINT32 & dynadjust::networkadjust::dna_adjust::incrementIteration ( )

Definition at line 181 of file dnaadjust.cpp.

{ 
    boost::lock_guard<boost::mutex> lock(current_iterationMutex);
    return ++currentIteration_; 
}

References dynadjust::networkadjust::current_iterationMutex, and currentIteration_.

Referenced by AdjustPhased(), AdjustPhasedMultiThread(), and AdjustSimultaneous().

Here is the caller graph for this function:

◆ initialiseIteration()

void dynadjust::networkadjust::dna_adjust::initialiseIteration ( const UINT32 & iteration = 0 )

Definition at line 187 of file dnaadjust.cpp.

{ 
    boost::lock_guard<boost::mutex> lock(current_iterationMutex);
    currentIteration_ = iteration; 
}

References dynadjust::networkadjust::current_iterationMutex, and currentIteration_.

Referenced by AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), and InitialiseAdjustment().

Here is the caller graph for this function:

◆ CurrentBlock()

UINT32 dynadjust::networkadjust::dna_adjust::CurrentBlock ( ) const

inline

Definition at line 288 of file dnaadjust.hpp.

288{ return currentBlock_; };

References currentBlock_.

◆ SetcurrentBlock()

void dynadjust::networkadjust::dna_adjust::SetcurrentBlock ( const UINT32 b )

inline

Definition at line 290 of file dnaadjust.hpp.

290{ currentBlock_ = b; };

References currentBlock_.

Referenced by AdjustPhasedForward(), AdjustPhasedMultiThread(), AdjustPhasedReverse(), AdjustPhasedReverseCombine(), and PrepareAdjustment().

Here is the caller graph for this function:

◆ SetmaxCorr()

void dynadjust::networkadjust::dna_adjust::SetmaxCorr ( const double c )

inline

Definition at line 292 of file dnaadjust.hpp.

                                           {
 
        boost::lock_guard<boost::mutex> lock(maxCorrMutex);
        maxCorr_ = c;
    };

References maxCorr_, and dynadjust::networkadjust::maxCorrMutex.

Referenced by UpdateEstimatesFinal(), and UpdateEstimatesForward().

Here is the caller graph for this function:

◆ blockCount()

UINT32 dynadjust::networkadjust::dna_adjust::blockCount ( ) const

inline

Definition at line 298 of file dnaadjust.hpp.

298{ return blockCount_; }

References blockCount_.

Referenced by PrintSummaryMessage().

Here is the caller graph for this function:

◆ adjustTime()

boost::posix_time::milliseconds dynadjust::networkadjust::dna_adjust::adjustTime ( ) const

inline

Definition at line 299 of file dnaadjust.hpp.

                                                          {
        return total_time_;
    }

References total_time_.

Referenced by main().

Here is the caller graph for this function:

◆ processingForward()

bool dynadjust::networkadjust::dna_adjust::processingForward ( )

inline

Definition at line 302 of file dnaadjust.hpp.

302{ return forward_; }

References forward_.

◆ processingCombine()

bool dynadjust::networkadjust::dna_adjust::processingCombine ( )

inline

Definition at line 303 of file dnaadjust.hpp.

303{ return isCombining_; }

References isCombining_.

◆ GetDegreesOfFreedom()

int dynadjust::networkadjust::dna_adjust::GetDegreesOfFreedom ( ) const

inline

Definition at line 304 of file dnaadjust.hpp.

304{ return degreesofFreedom_; }

References degreesofFreedom_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetMeasurementCount()

UINT32 dynadjust::networkadjust::dna_adjust::GetMeasurementCount ( ) const

inline

Definition at line 305 of file dnaadjust.hpp.

305{ return measurementParams_; }

References measurementParams_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetUnknownsCount()

UINT32 dynadjust::networkadjust::dna_adjust::GetUnknownsCount ( ) const

inline

Definition at line 306 of file dnaadjust.hpp.

306{ return unknownParams_; }

References unknownParams_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetChiSquared()

double dynadjust::networkadjust::dna_adjust::GetChiSquared ( ) const

inline

Definition at line 307 of file dnaadjust.hpp.

307{ return chiSquared_; }

References chiSquared_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetSigmaZero()

double dynadjust::networkadjust::dna_adjust::GetSigmaZero ( ) const

inline

Definition at line 308 of file dnaadjust.hpp.

308{ return sigmaZero_; }

References sigmaZero_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetPotentialOutlierCount()

UINT32 dynadjust::networkadjust::dna_adjust::GetPotentialOutlierCount ( ) const

inline

Definition at line 309 of file dnaadjust.hpp.

                                                   {
        return potentialOutlierCount_;
    }

References potentialOutlierCount_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetChiSquaredUpperLimit()

double dynadjust::networkadjust::dna_adjust::GetChiSquaredUpperLimit ( ) const

inline

Definition at line 312 of file dnaadjust.hpp.

                                                  {
        return chiSquaredUpperLimit_;
    }

References chiSquaredUpperLimit_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetChiSquaredLowerLimit()

double dynadjust::networkadjust::dna_adjust::GetChiSquaredLowerLimit ( ) const

inline

Definition at line 315 of file dnaadjust.hpp.

                                                  {
        return chiSquaredLowerLimit_;
    }

References chiSquaredLowerLimit_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetGlobalPelzerRel()

double dynadjust::networkadjust::dna_adjust::GetGlobalPelzerRel ( ) const

inline

Definition at line 318 of file dnaadjust.hpp.

                                             {
        return globalPelzerReliability_;
    }

References globalPelzerReliability_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetTestResult()

UINT32 dynadjust::networkadjust::dna_adjust::GetTestResult ( ) const

inline

Definition at line 321 of file dnaadjust.hpp.

321{ return passFail_; }

References passFail_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetAllFixed()

bool dynadjust::networkadjust::dna_adjust::GetAllFixed ( ) const

inline

Definition at line 322 of file dnaadjust.hpp.

322{ return allStationsFixed_; }

References allStationsFixed_.

Referenced by GenerateStatistics().

Here is the caller graph for this function:

◆ GetMemoryFootprint()

void dynadjust::networkadjust::dna_adjust::GetMemoryFootprint	(	double &	memory,
		const _MEM_UNIT_	unit )

Definition at line 621 of file dnaadjust.cpp.

{
    UINT32 b, i, w(PRINT_VAR_PAD+NUMERIC_WIDTH);
    UINT32 precision(2);
    size_t size(0);
 
    std::stringstream ss, st;
    if (projectSettings_.g.verbose > 0)
    {
        // Print title
        ss << std::endl << std::left << std::setw(PRINT_VAR_PAD) << "+ Memory footprint:";
        st << "Size";
        switch (unit)
        {
        case GIGABYTE_SIZE:
            st << "(GB) ";
            precision = 2;
            break;
        case MEGABYTE_SIZE:
            st << "(MB) ";
            precision = 1;
            break;
        case KILOBYTE_SIZE:
        default:
            st << "(kB) ";
            precision = 0;  
            break;
        }
 
        ss << std::right << std::setw(NUMERIC_WIDTH) << st.str() << std::endl;
 
        // Print line
        ss << " ";
        for (i=0; i<w; ++i)
            ss << "-";
        ss << std::endl;
    }
    
    double tmp;
    memory = 0.0;
    
    // binary stations
    memory += (tmp = static_cast<double>(bstBinaryRecords_.size()) / unit * sizeof(station_t));
    if (projectSettings_.g.verbose > 0)
        ss << std::left << std::setw(PRINT_VAR_PAD) << "  Binary station file" << 
            std::right << std::setw(NUMERIC_WIDTH) << std::fixed << std::setprecision(precision) << tmp << std::endl;
    
    // binary measurements
    memory += (tmp = static_cast<double>(bmsBinaryRecords_.size()) / unit * sizeof(measurement_t));
    if (projectSettings_.g.verbose > 0)
        ss << std::left << std::setw(PRINT_VAR_PAD) << "  Binary measurement file" << 
            std::right << std::setw(NUMERIC_WIDTH) << std::fixed << std::setprecision(precision) << tmp << std::endl;
    
    // Associated Station List
    memory += (tmp = static_cast<double>(vAssocStnList_.size()) / unit * sizeof(CAStationList));
    if (projectSettings_.g.verbose > 0)
        ss << std::left << std::setw(PRINT_VAR_PAD) << "  Associated station list" << 
            std::right << std::setw(NUMERIC_WIDTH) << std::fixed << std::setprecision(precision) << tmp << std::endl;
    
    // Associated Measurement List
    memory += (tmp = static_cast<double>(vAssocMsrList_.size()) / unit * sizeof(UINT32));
    if (projectSettings_.g.verbose > 0)
        ss << std::left << std::setw(PRINT_VAR_PAD) << "  Associated measurement list" << 
            std::right << std::setw(NUMERIC_WIDTH) << std::fixed << std::setprecision(precision) << tmp << std::endl;
    
    // double type variables
    size = 0;
    size += v_sigmaZero_.size();
    size += v_chiSquaredUpperLimit_.size();
    size += v_chiSquaredLowerLimit_.size();
    memory += (tmp = static_cast<double>(size) / unit * sizeof(double));
    if (projectSettings_.g.verbose > 0)
        ss << std::left << std::setw(PRINT_VAR_PAD) << "  Statistical variables" << 
            std::right << std::setw(NUMERIC_WIDTH) << std::fixed << std::setprecision(precision) << tmp << std::endl;
    
    // matrix_2d type variables
    tmp = 0;
    for (b=0; b<blockCount_; ++b)
    {
        tmp += (static_cast<double>(v_originalStations_.at(b).get_size()));
        tmp += (static_cast<double>(v_design_.at(b).get_size()));
        tmp += (static_cast<double>(v_measMinusComp_.at(b).get_size()));
        tmp += (static_cast<double>(v_AtVinv_.at(b).get_size()));
        tmp += (static_cast<double>(v_normals_.at(b).get_size()));
        tmp += (static_cast<double>(v_estimatedStations_.at(b).get_size()));
        
        if (projectSettings_.a.adjust_mode == PhasedMode)
        {
            tmp += (static_cast<double>(v_rigorousStations_.at(b).get_size()));
            tmp += (static_cast<double>(v_junctionVariances_.at(b).get_size()));
            tmp += (static_cast<double>(v_junctionVariancesFwd_.at(b).get_size()));
            tmp += (static_cast<double>(v_junctionEstimatesFwd_.at(b).get_size()));
            tmp += (static_cast<double>(v_junctionEstimatesRev_.at(b).get_size()));
        }
        tmp += (static_cast<double>(v_rigorousVariances_.at(b).get_size()));
        tmp += (static_cast<double>(v_precAdjMsrsFull_.at(b).get_size()));
        tmp += (static_cast<double>(v_corrections_.at(b).get_size()));
    }
 
    tmp *= sizeof(double);
    tmp /= unit;
    memory += tmp;
 
    if (projectSettings_.g.verbose > 0)
        ss << std::left << std::setw(PRINT_VAR_PAD) << "  Matrix variables" << 
            std::right << std::setw(NUMERIC_WIDTH) << std::fixed << std::setprecision(precision) << tmp << std::endl;
 
    if (projectSettings_.a.multi_thread)
    {
        tmp = 0;
        for (b=0; b<blockCount_; ++b)
        {
            if (!v_designR_.empty())
                tmp += (static_cast<double>(v_designR_.at(b).get_size()));
            if (!v_measMinusCompR_.empty())
                tmp += (static_cast<double>(v_measMinusCompR_.at(b).get_size()));
            if (!v_AtVinvR_.empty())
                tmp += (static_cast<double>(v_AtVinvR_.at(b).get_size()));
            if (!v_normalsR_.empty())
                tmp += (static_cast<double>(v_normalsR_.at(b).get_size()));
            if (!v_estimatedStationsR_.empty())
                tmp += (static_cast<double>(v_estimatedStationsR_.at(b).get_size()));
            if (!v_junctionVariancesR_.empty())
                tmp += (static_cast<double>(v_junctionVariancesR_.at(b).get_size()));
            if (!v_normalsRC_.empty())
                tmp += (static_cast<double>(v_normalsRC_.at(b).get_size()));
            if (!v_correctionsR_.empty())
                tmp += (static_cast<double>(v_correctionsR_.at(b).get_size()));
        }
 
        tmp *= sizeof(double);
        tmp /= unit;
        memory += tmp;
 
        if (projectSettings_.g.verbose > 0)
            ss << std::left << std::setw(PRINT_VAR_PAD) << "  MT matrix variables" << 
                std::right << std::setw(NUMERIC_WIDTH) << std::fixed << std::setprecision(precision) << tmp << std::endl;
    }   
    // UINT32
    size = 0;
    size += v_ContiguousNetList_.size();
    size += v_pseudoMeasCountFwd_.size();
    size += v_measurementParams_.size();
    size += v_measurementCount_.size();
    size += v_measurementVarianceCount_.size();
    size += v_unknownParams_.size();
    size += v_unknownsCount_.size();
    size += v_parameterStationCount_.size();
 
    for (b=0; b<blockCount_; ++b)
    {
        size += v_ISL_.at(b).size();
        if (projectSettings_.a.adjust_mode == PhasedMode)
        {
            size += v_JSL_.at(b).size();
            size += v_CML_.at(b).size();
        }
        size += v_parameterStationList_.at(b).size();
    }
    tmp = static_cast<double>(size);
    tmp *= sizeof(UINT32);
    tmp /= unit;
    memory += tmp;
 
    if (projectSettings_.g.verbose > 0)
        ss << std::left << std::setw(PRINT_VAR_PAD) << "  Arrays, counters and indices" << 
            std::right << std::setw(NUMERIC_WIDTH) << std::fixed << std::setprecision(precision) << tmp << std::endl;
 
 
    if (projectSettings_.g.verbose > 0)
    {
        ss << " ";
        for (i=0; i<w; ++i)
            ss << "-";
        ss << std::endl;
        ss << std::left << std::setw(PRINT_VAR_PAD) << "  Total" << std::right << std::setw(NUMERIC_WIDTH) << std::fixed << std::setprecision(precision) << memory << std::endl << std::endl;
        debug_file << ss.str();
    }
}

References blockCount_, bmsBinaryRecords_, bstBinaryRecords_, debug_file, GIGABYTE_SIZE, KILOBYTE_SIZE, MEGABYTE_SIZE, NUMERIC_WIDTH(), PhasedMode, PRINT_VAR_PAD(), projectSettings_, v_AtVinv_, v_AtVinvR_, v_chiSquaredLowerLimit_, v_chiSquaredUpperLimit_, v_CML_, v_ContiguousNetList_, v_corrections_, v_correctionsR_, v_design_, v_designR_, v_estimatedStations_, v_estimatedStationsR_, v_ISL_, v_JSL_, v_junctionEstimatesFwd_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesFwd_, v_junctionVariancesR_, v_measMinusComp_, v_measMinusCompR_, v_measurementCount_, v_measurementParams_, v_measurementVarianceCount_, v_normals_, v_normalsR_, v_normalsRC_, v_originalStations_, v_parameterStationCount_, v_parameterStationList_, v_precAdjMsrsFull_, v_pseudoMeasCountFwd_, v_rigorousStations_, v_rigorousVariances_, v_sigmaZero_, v_unknownParams_, v_unknownsCount_, vAssocMsrList_, and vAssocStnList_.

Referenced by PrepareAdjustment(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadSegmentationFileParameters()

void dynadjust::networkadjust::dna_adjust::LoadSegmentationFileParameters ( const std::string & seg_filename )

Definition at line 14821 of file dnaadjust.cpp.

{
    UINT32 blockThreshold, minInnerStns;
 
    try {
        // Load segmentation file.  Throws runtime_error on failure.
        dna_io_seg seg;
        seg.load_seg_file_header_f(seg_filename, 
            blockCount_, blockThreshold, minInnerStns);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
}

References blockCount_, dynadjust::iostreams::dna_io_seg::load_seg_file_header_f(), and SignalExceptionAdjustment().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SerialiseAdjustedVarianceMatrices()

void dynadjust::networkadjust::dna_adjust::SerialiseAdjustedVarianceMatrices ( )

Definition at line 7765 of file dnaadjust.cpp.

{
    // No need to facilitate serialising if network adjustment is in stage,
    // as this will already be taken care of
    if (projectSettings_.a.stage)
        return;
 
    // Create file streams and memory map regions
    projectSettings_.a.recreate_stage_files = 1;
    OpenStageFileStreams(2, sf_rigorous_vars, sf_prec_adj_msrs);
    ReserveBlockMapRegions(2, sf_rigorous_vars, sf_prec_adj_msrs);
 
    // Now offload matrices to new .mtx stage files
 
    UINT32 block;
    
    for (block=0; block<blockCount_; ++block)
    {
        // Set memory mapped file region offsets
        SetRegionOffsets(block, 2, sf_rigorous_vars, sf_prec_adj_msrs);
 
        // Write to disk (the memory mapped file)
        f_rigorousVariances_ << v_rigorousVariances_.at(block);         // ...rva.mtx
        f_precAdjMsrs_ << v_precAdjMsrsFull_.at(block);                 // ...pam.mtx
    }
 
    // Close rigorous variances stream
    f_rigorousVariances_.close();
    f_precAdjMsrs_.close();
}

References blockCount_, f_precAdjMsrs_, f_rigorousVariances_, OpenStageFileStreams(), projectSettings_, ReserveBlockMapRegions(), SetRegionOffsets(), sf_prec_adj_msrs, sf_rigorous_vars, v_precAdjMsrsFull_, and v_rigorousVariances_.

Referenced by SerialiseVarianceMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeSerialiseAdjustedVarianceMatrices()

void dynadjust::networkadjust::dna_adjust::DeSerialiseAdjustedVarianceMatrices ( )

Definition at line 7715 of file dnaadjust.cpp.

{
    // No need to facilitate serialising if network adjustment is in stage,
    // as this will already be taken care of
    if (projectSettings_.a.stage)
        return;
 
    // Create file streams and memory map regions
    OpenStageFileStreams(2, sf_rigorous_vars, sf_prec_adj_msrs);
    ReserveBlockMapRegions(2, sf_rigorous_vars, sf_prec_adj_msrs);
 
    for (UINT32 block=0; block<blockCount_; ++block)
    {
        // Set Region offsets
        SetRegionOffsets(block, 2, sf_rigorous_vars, sf_prec_adj_msrs);
 
        // Prepare mapping regions
        PrepareMemoryMapRegions(block, 2, sf_rigorous_vars, sf_prec_adj_msrs);
    }
 
    
    try {
        // Set memory mapped file regions
        // NOTE - previously created files must exist and match the 
        // dimensions of the current matrix sizes           
        SetMapRegions(2, sf_rigorous_vars, sf_prec_adj_msrs);
        
    }
    catch (boost::interprocess::interprocess_exception& e){
        std::stringstream ss;
        ss << "DeSerialiseAdjustedVarianceMatrices() terminated while creating memory map" << std::endl;
        ss << "  regions from mtx file. Details:\n  " << e.what() << std::endl;
        adj_file << std::endl << "- Error: " << ss.str() << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    // Now load up matrix from .mtx file
    for (UINT32 block=0; block<blockCount_; ++block)
    {
        // Read this block
        DeserialiseBlockFromMappedFile(block, 2,
            sf_rigorous_vars, sf_prec_adj_msrs);
    }
 
    // Close rigorous variances stream
    f_rigorousVariances_.close();
    f_precAdjMsrs_.close();
}

References adj_file, blockCount_, DeserialiseBlockFromMappedFile(), f_precAdjMsrs_, f_rigorousVariances_, OpenStageFileStreams(), PrepareMemoryMapRegions(), projectSettings_, ReserveBlockMapRegions(), SetMapRegions(), SetRegionOffsets(), sf_prec_adj_msrs, sf_rigorous_vars, and SignalExceptionAdjustment().

Referenced by DeserialiseVarianceMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NewMessagesAvailable()

bool dynadjust::networkadjust::dna_adjust::NewMessagesAvailable ( )

inline

Definition at line 333 of file dnaadjust.hpp.

333{ return iterationQueue_.not_empty(); }

dynadjust::networkadjust::dna_adjust::iterationQueue_

concurrent_queue< UINT32 > iterationQueue_

Definition dnaadjust.hpp:1257

References iterationQueue_.

Referenced by PrintSummaryMessage().

Here is the caller graph for this function:

◆ GetMessageIteration()

bool dynadjust::networkadjust::dna_adjust::GetMessageIteration ( UINT32 & iteration )

inline

Definition at line 334 of file dnaadjust.hpp.

                                                       {
        return iterationQueue_.front_and_pop(iteration);
    }

References iterationQueue_.

Referenced by PrintSummaryMessage().

Here is the caller graph for this function:

◆ GetMaxCorrection()

std::string dynadjust::networkadjust::dna_adjust::GetMaxCorrection ( const UINT32 & iteration ) const

inline

Definition at line 339 of file dnaadjust.hpp.

                                                                     {
        if (iteration == 0)
            return iterationCorrections_.get_message(iteration); // safe guard
        return iterationCorrections_.get_message(iteration - 1);
    };

References iterationCorrections_.

Referenced by PrintSummaryMessage().

Here is the caller graph for this function:

◆ ThreadSafeWritetoAdjFile()

void dynadjust::networkadjust::dna_adjust::ThreadSafeWritetoAdjFile ( const std::string & s )

inline

Definition at line 348 of file dnaadjust.hpp.

                                                             {
        concurrent_adj_ofstream.wrtie(adj_file, s);
    }

References adj_file, and concurrent_adj_ofstream.

Referenced by WriteMsrtoAdjFile(), WriteStatstoAdjFile(), and WriteStntoAdjFile().

Here is the caller graph for this function:

◆ WriteStatstoAdjFile()

void dynadjust::networkadjust::dna_adjust::WriteStatstoAdjFile ( const std::string & s )

inline

Definition at line 351 of file dnaadjust.hpp.

                                                        {
        if (projectSettings_.o._adj_stat_iteration)
            ThreadSafeWritetoAdjFile(s);
    }

References projectSettings_, and ThreadSafeWritetoAdjFile().

Here is the call graph for this function:

◆ WriteStntoAdjFile()

void dynadjust::networkadjust::dna_adjust::WriteStntoAdjFile ( const std::string & s )

inline

Definition at line 355 of file dnaadjust.hpp.

                                                      {
        if (projectSettings_.o._adj_stn_iteration)
            ThreadSafeWritetoAdjFile(s);
    }

References projectSettings_, and ThreadSafeWritetoAdjFile().

Here is the call graph for this function:

◆ WriteMsrtoAdjFile()

void dynadjust::networkadjust::dna_adjust::WriteMsrtoAdjFile ( const std::string & s )

inline

Definition at line 359 of file dnaadjust.hpp.

                                                      {
        if (projectSettings_.o._adj_msr_iteration)
            ThreadSafeWritetoAdjFile(s);
    }

References projectSettings_, and ThreadSafeWritetoAdjFile().

Here is the call graph for this function:

◆ ThreadSafeWritetoDbgFile()

void dynadjust::networkadjust::dna_adjust::ThreadSafeWritetoDbgFile ( const std::string & s )

inline

Definition at line 364 of file dnaadjust.hpp.

                                                             {
        concurrent_adj_ofstream.wrtie(debug_file, s);
    }

References concurrent_adj_ofstream, and debug_file.

◆ AdjustNetwork()

_ADJUST_STATUS_ dynadjust::networkadjust::dna_adjust::AdjustNetwork ( )

Definition at line 2308 of file dnaadjust.cpp.

{
    isAdjusting_ = true;
    isIterationComplete_ = false;
    isAdjustmentQuestionable_ = false;
    iterationCorrections_.clear_messages();
 
    if (projectSettings_.o._database_ids)
        LoadDatabaseId();
 
    switch (projectSettings_.a.adjust_mode)
    {
    case SimultaneousMode:
        if (!projectSettings_.a.report_mode)
            adj_file << std::endl << "+ Commencing simultaneous adjustment" << std::endl << std::endl;
        AdjustSimultaneous();
        return adjustStatus_;
 
    case PhasedMode:
        if (!projectSettings_.a.report_mode)
            adj_file << std::endl << "+ Commencing sequential phased adjustment";
 
        if (projectSettings_.a.multi_thread)
        {   
            if (!projectSettings_.a.report_mode)
            {
                adj_file << std::endl << "  Optimised for concurrent processing via multi-threading." << std::endl;
                adj_file << "  The active CPU supports the execution of " << boost::thread::hardware_concurrency() << " concurrent threads." << std::endl;
                adj_file << std::endl;
            }
            AdjustPhasedMultiThread();
            return adjustStatus_;
        }
 
        if (!projectSettings_.a.report_mode)
            adj_file << std::endl << std::endl;
        AdjustPhased();
 
        return adjustStatus_;
    
    case Phased_Block_1Mode:
        if (!projectSettings_.a.report_mode)
        {
            adj_file << std::endl << "+ Commencing sequential phased adjustment, producing rigorous estimates" << std::endl;
            adj_file << "  for block 1 only" << std::endl << std::endl;
            adj_file << 
                "- Warning: Depending on the quality of the apriori station estimates, further" << std::endl <<
                "  iterations may be needed. --block1-phased mode should only be used once" << std::endl <<
                "  rigorous estimates have been produced for the entire network."<< std::endl << std::endl;
        }
 
        AdjustPhasedBlock1();
        return adjustStatus_;
    
    default:
        std::stringstream ss;
        ss << "AdjustNetwork(): Unknown adjustment type" << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    return adjustStatus_;
}

References adj_file, AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), adjustStatus_, isAdjusting_, isAdjustmentQuestionable_, isIterationComplete_, iterationCorrections_, LoadDatabaseId(), Phased_Block_1Mode, PhasedMode, projectSettings_, SignalExceptionAdjustment(), and SimultaneousMode.

Here is the call graph for this function:

◆ FirstBlock()

bool dynadjust::networkadjust::dna_adjust::FirstBlock ( const UINT32 & block ) const

inline

Definition at line 387 of file dnaadjust.hpp.

                                                      {
        return v_blockMeta_.at(block)._blockFirst;
    }

References v_blockMeta_.

◆ LastBlock()

bool dynadjust::networkadjust::dna_adjust::LastBlock ( const UINT32 & block ) const

inline

Definition at line 391 of file dnaadjust.hpp.

                                                     {
        return v_blockMeta_.at(block)._blockLast;
    }

References v_blockMeta_.

◆ SignalExceptionAdjustment()

void dynadjust::networkadjust::dna_adjust::SignalExceptionAdjustment	(	const std::string &	msg,
		const UINT32	block_no )

Definition at line 14018 of file dnaadjust.cpp.

{
    adjustStatus_ = ADJUST_EXCEPTION_RAISED;
 
    isPreparing_ = false;
    isCombining_ = false;
    isAdjusting_ = false;
 
    std::string error_msg(msg);
 
    switch (projectSettings_.a.adjust_mode)
    {
    case Phased_Block_1Mode:
    case PhasedMode:
        std::stringstream ss;
        ss << msg << std::endl << "  Phased adjustment terminated whilst processing block " << block_no + 1 << std::endl;
        error_msg = ss.str();
    }
    
    throw boost::enable_current_exception(std::runtime_error(error_msg));
}

References ADJUST_EXCEPTION_RAISED, adjustStatus_, isAdjusting_, isCombining_, isPreparing_, Phased_Block_1Mode, PhasedMode, and projectSettings_.

Referenced by AdjustNetwork(), ApplyAdditionalConstraints(), ComputePrecisionAdjMsrs(), CreateMsrToStnTally(), DeSerialiseAdjustedVarianceMatrices(), FormInverseVarianceMatrixReduced(), InitialiseTypeBUncertainties(), LoadDatabaseId(), LoadNetworkFiles(), LoadPhasedBlocks(), LoadSegmentationFile(), LoadSegmentationFileParameters(), LoadSegmentationMetrics(), LoadStationMap(), LoadVarianceMatrix_D(), LoadVarianceMatrix_G(), LoadVarianceMatrix_X(), LoadVarianceMatrix_Y(), OpenOutputFileStreams(), OpenStageFileStreams(), PrepareAdjustment(), PrintAdjMeasurements(), PrintAdjStations(), PrintAdjStationsUniqueList(), PrintEstimatedStationCoordinatestoDNAXML(), PrintEstimatedStationCoordinatestoDNAXML_Y(), PrintEstimatedStationCoordinatestoSNX(), PrintNetworkStationCorrections(), PrintPositionalUncertainty(), SerialiseBlockToDisk(), SetDefaultReferenceFrame(), Solve(), SolveMTTry(), SolveTry(), UpdateAdjustment(), UpdateBinaryFiles(), UpdateDesignNormalMeasMatrices(), UpdateDesignNormalMeasMatrices_D(), UpdateIgnoredMeasurements(), UpdateIgnoredMeasurements_A(), UpdateIgnoredMeasurements_D(), UpdateIgnoredMeasurements_S(), and UpdateNormals().

Here is the caller graph for this function:

◆ CreateMeasurementTally()

void dynadjust::networkadjust::dna_adjust::CreateMeasurementTally ( const UINT32 & block = 0 )

Definition at line 241 of file dnaadjust.cpp.

{
    v_msrTally_.at(block).CreateTally(bmsBinaryRecords_, v_CML_.at(block));
}

References bmsBinaryRecords_, v_CML_, and v_msrTally_.

Referenced by PrepareAdjustment().

Here is the caller graph for this function:

◆ SolveTry()

void dynadjust::networkadjust::dna_adjust::SolveTry	(	bool	COMPUTE_INVERSE,
		const UINT32 &	block = 0 )

Definition at line 7562 of file dnaadjust.cpp.

{
    // Least Squares Solution
    try {            
        Solve(COMPUTE_INVERSE, block);
    }
    catch (const std::runtime_error& e) {
 
        // debug matrices if required
        debug_SolutionInformation(block);
 
        // Could not invert matrix.  Fire an exception
        SignalExceptionAdjustment(e.what(), block);
    }
}

References debug_SolutionInformation(), SignalExceptionAdjustment(), and Solve().

Referenced by AdjustPhasedForward(), AdjustPhasedReverse(), AdjustPhasedReverseCombine(), and AdjustSimultaneous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SolveMTTry()

void dynadjust::networkadjust::dna_adjust::SolveMTTry	(	bool	COMPUTE_INVERSE,
		const UINT32 &	block = 0 )

Definition at line 274 of file dnaadjust-multi.cpp.

{
    // Least Squares Solution
    try {            
        SolveMT(COMPUTE_INVERSE, block);
    }
    catch (const std::runtime_error& e) {
 
        // could not invert matrix.  throw error
 
        if (projectSettings_.g.verbose)
        {
            debug_file << "Block " << block + 1 << " (reverse, multi-thread)" << std::endl;
            debug_file << "Pre-adjustment Estimates" << std::fixed << std::setprecision(16) << v_estimatedStationsR_.at(block);
            debug_file << "Design" << std::fixed << std::setprecision(16) << v_designR_.at(block);
            debug_file << "Measurements" << std::fixed << std::setprecision(16) << v_measMinusCompR_.at(block);
            debug_file << "At * V-inv" << std::fixed << std::setprecision(16) << v_AtVinvR_.at(block);
            debug_file << "Normals " << std::fixed << std::setprecision(16) << v_normalsR_.at(block) << std::endl;
            debug_file.flush();
        }
 
        SignalExceptionAdjustment(e.what(), block);
    }
}

References debug_file, projectSettings_, SignalExceptionAdjustment(), SolveMT(), v_AtVinvR_, v_designR_, v_estimatedStationsR_, v_measMinusCompR_, and v_normalsR_.

Here is the call graph for this function:

◆ Solve()

void dynadjust::networkadjust::dna_adjust::Solve	(	bool	COMPUTE_INVERSE,
		const UINT32 &	block = 0 )

Definition at line 7579 of file dnaadjust.cpp.

{
    // debug matrices if required
    debug_SolutionInformation(block);
 
    if (COMPUTE_INVERSE)
    {
        // When non-GPS measurements exist, partial derivatives will vary upon
        // each iteration due to changes in the latest estimates, and so
        // normals will be reformed.  Hence, compute inverse.
        // The procedure for constraining free coordinates causes the elements 
        // in the normal matrix to vary greatly in magnitude.  In some cases,
        // this opens the possibility of a loss of accuracy in the 
        // matrix inversion process as the algorithm will be repeatedly 
        // computing the difference between numbers of vastly different 
        // magnitude. Inaccuracy in the inversion can be mitigated by scaling 
        // the normal matrix before inversion and subsequently reversing the effect.
        //
 
        // 1. Create scalar matrix
        matrix_2d *S = nullptr, *SN = nullptr;
 
        if (projectSettings_.a.scale_normals_to_unity)
        {
            S = new matrix_2d(v_normals_.at(block).rows(), v_normals_.at(block).rows());
            SN = new matrix_2d(v_normals_.at(block).rows(), v_normals_.at(block).rows());
            for (UINT32 i(0); i<v_normals_.at(block).rows(); ++i)
                S->put(i, i, sqrt(v_normals_.at(block).get(i, i)));
            // 2. Scale Normals to reduce the diagonal elements of Normals to unity
            //SN->multiply(*S, v_normals_.at(block));
            SN->multiply(*S, "N", v_normals_.at(block), "N");
            
            //v_normals_.at(block).multiply(*SN, *S);
            v_normals_.at(block).multiply(*SN, "N", *S, "N");
        }
    
        // Calculate Inverse of AT * V-1 * A
        FormInverseVarianceMatrix(&(v_normals_.at(block)));
 
        // Check for a failed inverse solution
        if (boost::math::isnan(v_normals_.at(block).get(0, 0)) || 
            boost::math::isinf(v_normals_.at(block).get(0, 0)))
        {
            std::stringstream ss;
            ss << "Solve(): Invalid variance matrix:" << std::endl;
            ss << std::setprecision(6) << std::fixed << v_normals_.at(block);
            SignalExceptionAdjustment(ss.str(), 0);
        }
        // 2. Compute inverse of N (via S * (SNS)-1 * S)
        if (projectSettings_.a.scale_normals_to_unity)
        {
            //SN->multiply(*S, v_normals_.at(block));
            SN->multiply(*S, "N", v_normals_.at(block), "N");
 
            //v_normals_.at(block).multiply(*SN, *S);
            v_normals_.at(block).multiply(*SN, "N", *S, "N");
 
            delete S;
            delete SN;
        }
    }
    
    if (projectSettings_.g.verbose > 0)
    {
        debug_file << "Block " << block + 1;
        if (projectSettings_.a.adjust_mode != SimultaneousMode)
            debug_file << (forward_ ? " (Forward)" : " (Reverse)");
        debug_file << std::endl;
        debug_file << "Precisions" << std::fixed << std::setprecision(16) << v_normals_.at(block) << std::endl;
    }
    
    // compute weighted "measured minus computed"
    matrix_2d At_Vinv_m(v_design_.at(block).columns(), 1);
    At_Vinv_m.multiply(v_AtVinv_.at(block), "N", v_measMinusComp_.at(block), "N");
    
    // Solve corrections from normal equations
    v_corrections_.at(block).redim(v_design_.at(block).columns(), 1);
    v_corrections_.at(block).multiply(v_normals_.at(block), "N", At_Vinv_m, "N");
 
    if (projectSettings_.g.verbose > 0)
    {
 
        if (projectSettings_.a.multi_thread)
            dbg_file_mutex.lock();
 
        it_vUINT32 _it_stn;
        UINT32 i;
        
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
        case PhasedMode:
            for (i=0; i<v_parameterStationList_.at(block).size(); ++i)
            {
                debug_file << bstBinaryRecords_.at(v_parameterStationList_.at(block).at(i)).stationName;
                if ((_it_stn = find(v_ISL_.at(block).begin(), v_ISL_.at(block).end(), v_parameterStationList_.at(block).at(i))) != v_ISL_.at(block).end())
                    debug_file << "i ";
                else if ((_it_stn = find(v_JSL_.at(block).begin(), v_JSL_.at(block).end(), v_parameterStationList_.at(block).at(i))) != v_JSL_.at(block).end())
                        debug_file << "j ";
                else 
                    debug_file << " ";                
            }
            break;
        case SimultaneousMode:
            for (i=0; i<v_ISL_.at(block).size(); ++i)
                debug_file << bstBinaryRecords_.at(v_ISL_.at(block).at(i)).stationName << " ";             
            break;
        }
 
        debug_file << std::endl;
        debug_file << "Block " << block + 1;
        if (projectSettings_.a.adjust_mode != SimultaneousMode)
            debug_file << (forward_ ? " (Forward)" : " (Reverse)");
        debug_file << std::endl;
        debug_file << "Weighted measurements" << std::fixed << std::setprecision(16) << At_Vinv_m << std::endl;
 
        debug_file << "Block " << block + 1;
        if (projectSettings_.a.adjust_mode != SimultaneousMode)
            debug_file << (forward_ ? " (Forward)" : " (Reverse)");
        debug_file << std::endl;
        debug_file << "Corrections" << std::fixed << std::setprecision(16) << v_corrections_.at(block) << std::endl;
        debug_file.flush();
 
        if (projectSettings_.a.multi_thread)
            dbg_file_mutex.unlock();
 
    }
}

References bstBinaryRecords_, dynadjust::networkadjust::dbg_file_mutex, debug_file, debug_SolutionInformation(), FormInverseVarianceMatrix(), forward_, dynadjust::math::matrix_2d::multiply(), Phased_Block_1Mode, PhasedMode, projectSettings_, dynadjust::math::matrix_2d::put(), SignalExceptionAdjustment(), SimultaneousMode, v_AtVinv_, v_corrections_, v_design_, v_ISL_, v_JSL_, v_measMinusComp_, v_normals_, and v_parameterStationList_.

Referenced by SolveTry().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SolveMT()

void dynadjust::networkadjust::dna_adjust::SolveMT	(	bool	COMPUTE_INVERSE,
		const UINT32 &	block )

Definition at line 299 of file dnaadjust-multi.cpp.

{
    if (COMPUTE_INVERSE)
    {
        // Compute inverse of normals (aposteriori variance matrix)
        // (AT * V-1 * A)-1
        FormInverseVarianceMatrix(&(v_normalsR_.at(block)));
    }
 
    // compute weighted "measured minus computed"
    matrix_2d At_Vinv_m(v_designR_.at(block).columns(), 1);
    At_Vinv_m.multiply(v_AtVinvR_.at(block), "N", v_measMinusCompR_.at(block), "N");
 
    // Solve corrections from normal equations
    v_correctionsR_.at(block).redim(v_designR_.at(block).columns(), 1);
    v_correctionsR_.at(block).multiply(v_normalsR_.at(block), "N", At_Vinv_m, "N");
 
    // debug output?
    if (projectSettings_.g.verbose > 3)
    {
        dbg_file_mutex.lock();
 
        UINT32 i;
        switch (projectSettings_.a.adjust_mode)
        {
        case PhasedMode:
            for (i=0; i<v_parameterStationList_.at(block).size(); ++i)
            {
                debug_file << bstBinaryRecords_.at(v_parameterStationList_.at(block).at(i)).stationName;
                if (find(v_ISL_.at(block).begin(), v_ISL_.at(block).end(), v_parameterStationList_.at(block).at(i)) != v_ISL_.at(block).end())
                    debug_file << "i ";
                else if (find(v_JSL_.at(block).begin(), v_JSL_.at(block).end(), v_parameterStationList_.at(block).at(i)) != v_JSL_.at(block).end())
                        debug_file << "j ";
                else 
                    debug_file << " ";                
            }
            break;
        }
 
        debug_file << std::endl;
        
        debug_file << "Block " << block + 1 << " (Reverse)";
        debug_file << std::endl;
        debug_file << "Pre-adjustment Estimates" << std::fixed << std::setprecision(16) << v_estimatedStationsR_.at(block);
        debug_file << "Block " << block + 1 << " (Reverse)";
        debug_file << std::endl;
        debug_file << "Design" << std::fixed << std::setprecision(16) << v_designR_.at(block);
        debug_file << "Block " << block + 1 << " (Reverse)";
        debug_file << std::endl;
        debug_file << "Measurements" << std::fixed << std::setprecision(16) << v_measMinusCompR_.at(block);
        debug_file << "Block " << block + 1 << " (Reverse)";
        debug_file << std::endl;
        debug_file << "At * V-inv" << std::fixed << std::setprecision(16) << v_AtVinvR_.at(block) << std::endl;
        debug_file << "Block " << block + 1 << " (Reverse)";
        debug_file << std::endl;
        debug_file << "Normals " << std::fixed << std::setprecision(16) << v_normalsR_.at(block) << std::endl;
        debug_file << "Block " << block + 1 << " (Reverse)";
        debug_file << std::endl;
        debug_file << "Precisions" << std::fixed << std::setprecision(16) << v_normalsR_.at(block) << std::endl;
        debug_file << "Block " << block + 1 << " (Reverse)";
        debug_file << std::endl;
        debug_file << "Corrections" << std::fixed << std::setprecision(16) << v_correctionsR_.at(block) << std::endl;
        debug_file.flush();
 
        dbg_file_mutex.unlock();
 
    }
}

References bstBinaryRecords_, dynadjust::networkadjust::dbg_file_mutex, debug_file, FormInverseVarianceMatrix(), dynadjust::math::matrix_2d::multiply(), PhasedMode, projectSettings_, v_AtVinvR_, v_correctionsR_, v_designR_, v_estimatedStationsR_, v_ISL_, v_JSL_, v_measMinusCompR_, v_normalsR_, and v_parameterStationList_.

Referenced by SolveMTTry().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CombineRequired()

bool dynadjust::networkadjust::dna_adjust::CombineRequired ( const UINT32 & block ) const

inline

Definition at line 410 of file dnaadjust.hpp.

                                                           {
        if (v_blockMeta_.at(block)._blockLast)
            return false;
        if (v_blockMeta_.at(block)._blockIsolated)
            return false;
        if (v_blockMeta_.at(block)._blockFirst)
            return false;
        return true;
    }

References v_blockMeta_.

Referenced by BackupNormals(), and PrepareAdjustmentCombine().

Here is the caller graph for this function:

◆ InitialiseandValidateMsrPointer()

bool dynadjust::networkadjust::dna_adjust::InitialiseandValidateMsrPointer	(	const it_vUINT32 &	_it_block_msr,
		it_vmsr_t &	_it_msr )

private

Definition at line 8761 of file dnaadjust.cpp.

{
    _it_msr = bmsBinaryRecords_.begin() + (*_it_block_msr);
 
    // Is this measurement ignored?
    if (_it_msr->ignore)
        return true;
 
    // Only pointers to the starting element of each measurement are kept. 
    // Hence, Y and Z and variance-covariance components are regarded as
    // non-measurement elements.  When one of these is found, 
    // continue to next element.  See declaration of measRecord.measStart 
    // for more info.
    if (_it_msr->measStart != xMeas)
        return true;
 
    return false;
}

References bmsBinaryRecords_, and xMeas.

Referenced by ComputeChiSquare(), ComputeGlobalPelzer(), ComputePrecisionAdjMsrs(), FillDesignNormalMeasurementsMatrices(), PrintCompMeasurements(), UpdateMsrRecords(), UpdateMsrTstatistic(), and UpdateNormals().

Here is the caller graph for this function:

◆ InitialiseMeasurement()

bool dynadjust::networkadjust::dna_adjust::InitialiseMeasurement	(	pit_vmsr_t	_it_msr,
		bool	buildnewMatrices )

private

Definition at line 4849 of file dnaadjust.cpp.

{
    if (buildnewMatrices)
    {
        // Was this measurement reduced from previous
        // adjustment, which was serialised to disk?
        if (bms_meta_.reduced)
            // Restore measured value
            (*_it_msr)->term1 = (*_it_msr)->preAdjMeas;
        else
            // This is the first time adjust has run, so
            // back up the raw measurement
            (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
        if (projectSettings_.a.stage)
            return true;
    }
 
    return false;
}

References bms_meta_, and projectSettings_.

Here is the caller graph for this function:

◆ RebuildNormals()

void dynadjust::networkadjust::dna_adjust::RebuildNormals	(	const UINT32	block,
		adjustOperation	direction,
		bool	AddConstraintStationstoNormals,
		bool	BackupNormals )

private

Definition at line 3691 of file dnaadjust.cpp.

{
    // Update measurements-computed vector using new estimates
    FillDesignNormalMeasurementsMatrices(false, block, false);
 
    // Update normal equations and add parameter station variances
    v_normals_.at(block).zero();
    UpdateNormals(block, false);
 
    if (!AddConstraintStationstoNormals)
        return;
 
    // Add parameter stations
    switch (direction)
    {
    case __forward__:
 
        // Back up normals.  This copy contains the contributions from all
        // apriori measurement variances, excluding parameter station 
        // variances and junction station variances
        if (BackupNormals)
            v_normalsR_.at(block) = v_normals_.at(block);
 
        AddConstraintStationstoNormalsForward(block);
        break;
 
    case __reverse__:
        AddConstraintStationstoNormalsReverse(block, false);
        break;
    default:
        break;
    }
}

References __forward__, __reverse__, AddConstraintStationstoNormalsForward(), AddConstraintStationstoNormalsReverse(), BackupNormals(), FillDesignNormalMeasurementsMatrices(), UpdateNormals(), v_normals_, and v_normalsR_.

Referenced by AdjustPhasedForward(), CarryForwardJunctions(), and CarryReverseJunctions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateAdjustment()

void dynadjust::networkadjust::dna_adjust::UpdateAdjustment ( bool iterate )

private

Definition at line 475 of file dnaadjust.cpp.

{
    isPreparing_ = true;
 
    UINT32 block;
 
    bool lastBlock, updateGeographicCoordinates;
        
    try {
    
        // Prepare initial matrices for least squares adjustment
        for (block=0; block<blockCount_; ++block)
        {
            if (IsCancelled())
                break;
 
            switch (projectSettings_.a.adjust_mode)
            {
            case PhasedMode:
            case Phased_Block_1Mode:
 
                lastBlock = v_blockMeta_.at(block)._blockLast;
                updateGeographicCoordinates = 
                    v_msrTally_.at(block).ContainsNonGPS() ||        // if this block contains measurements in the local reference frame, or
                    lastBlock ||                                    // if this is the last block, or
                    !iterate;                                       // if no further iterations are required
 
                if (updateGeographicCoordinates || lastBlock)
                    // For staged adjustments, load block info
                    if (projectSettings_.a.stage)
                        DeserialiseBlockFromMappedFile(block, 1, sf_estimated_stns);
 
                // The last block in the forward pass is rigorous.  However, the coordinates were not updated 
                // since both phased and multi thread adjustments require original coordinates for the reverse
                // pass, both of which take place after the forward pass has completed.
                if (lastBlock)
                {
                    // For staged adjustments, load block info
                    if (projectSettings_.a.stage)
                        DeserialiseBlockFromMappedFile(block, 4,
                            sf_normals, sf_original_stns, 
                            sf_rigorous_vars, sf_rigorous_stns);
 
                    v_estimatedStations_.at(block) = v_rigorousStations_.at(block);
                    v_originalStations_.at(block) = v_rigorousStations_.at(block);
                    v_normals_.at(block) = v_rigorousVariances_.at(block);
 
                    if (projectSettings_.a.stage)
                        SerialiseBlockToMappedFile(block, 2,
                            sf_estimated_stns, sf_original_stns);
                }
 
                // Update geographic coordinates if:
                //  - The network contains non-GPS measurements, so that partial
                //    derivatives can be correctly formed
                //  - This is the last block in a contiguous network
                //  - There are no more iterations required
                if (updateGeographicCoordinates)
                    UpdateGeographicCoordsPhased(block, &v_estimatedStations_.at(block));
 
                if (projectSettings_.a.stage)
                {
                    // For staged adjustments, unload all matrix data
                    UnloadBlock(block);
                    continue;
                }
 
                break;
            case SimultaneousMode:
                // Update geographic coordinates
                if (v_msrTally_.at(block).ContainsNonGPS() ||        // if this block contains measurements in the local reference frame, or
                    !iterate)                                       // if no further iterations are required
                    UpdateGeographicCoords();
                break;
            }
 
            // Update measurements-computed vector using new estimates
            FillDesignNormalMeasurementsMatrices(false, block, false);
 
            // If no further iterations are required, then don't update the normals.
            // This is because the inverse of the normals is needed for computing
            // precision of adjusted measurements, whereas UpdateNormals() only
            // produces normals prior to inversion.
            // Hence, only design and msr-comp are required so as to compute stats
            if (!iterate)
                continue;
            
            switch (projectSettings_.a.adjust_mode)
            {
            case PhasedMode:
            case Phased_Block_1Mode:
                v_normals_.at(block).zero();
                UpdateNormals(block, false);
                
                if (projectSettings_.a.multi_thread)
                {
                    v_estimatedStationsR_.at(block) = v_rigorousStations_.at(block);
 
                    // Update measurements-computed vector for reverse thread using new estimates
                    FillDesignNormalMeasurementsMatrices(false, block, true);
                }
 
                // Back up normals.  This copy contains the contributions from all
                // apriori measurement variances, excluding parameter station 
                // variances and junction station variances
                v_normalsR_.at(block) = v_normals_.at(block);              
                AddConstraintStationstoNormalsForward(block);
 
                break;
            case SimultaneousMode:
                if (v_msrTally_.at(0).ContainsNonGPS())
                {
                    // update normals
                    v_normals_.at(0).zero();
                    UpdateNormals(0, false);
                    AddConstraintStationstoNormalsSimultaneous(0);
                }
                break;
            }           
        }
    }
    catch (const NetMemoryException& e) {
        std::stringstream ss;
        double memory;
        try { GetMemoryFootprint(memory, GIGABYTE_SIZE); }
        catch (...) {}
 
        ss << "UpdateAdjustment(): Process terminated while allocating memory for the " << std::endl << "  adjustment matrices. " <<
            "Details: " << std::endl << "  " << e.what() << std::endl;
        ss << "  The memory footprint consumed by " << __BINARY_NAME__ << " is " << 
            std::fixed << std::setprecision(2) << memory << " GB" << std::endl;
        adj_file << "- Error:" << std::endl << "  " << ss.str();
        SignalExceptionAdjustment(ss.str(), block);
    }
    catch (const std::runtime_error& e) {
        std::stringstream ss;
        ss << "UpdateAdjustment(): Process terminated while updating the " << std::endl << "  adjustment matrices. " <<
            "Details: " << std::endl << "  " << e.what() << std::endl;
        adj_file << "- Error:" << std::endl << "  " << ss.str();
        SignalExceptionAdjustment(ss.str(), block);
    }       
    
    isPreparing_ = false;
}

References AddConstraintStationstoNormalsForward(), AddConstraintStationstoNormalsSimultaneous(), adj_file, blockCount_, DeserialiseBlockFromMappedFile(), FillDesignNormalMeasurementsMatrices(), GetMemoryFootprint(), GIGABYTE_SIZE, IsCancelled(), isPreparing_, Phased_Block_1Mode, PhasedMode, projectSettings_, SerialiseBlockToMappedFile(), sf_estimated_stns, sf_normals, sf_original_stns, sf_rigorous_stns, sf_rigorous_vars, SignalExceptionAdjustment(), SimultaneousMode, UnloadBlock(), UpdateGeographicCoords(), UpdateGeographicCoordsPhased(), UpdateNormals(), v_blockMeta_, v_estimatedStations_, v_estimatedStationsR_, v_msrTally_, v_normals_, v_normalsR_, v_originalStations_, v_rigorousStations_, v_rigorousVariances_, and dynadjust::exception::NetMemoryException::what().

Referenced by AdjustPhased(), AdjustPhasedMultiThread(), AdjustSimultaneous(), and GenerateStatistics().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ValidateandFinaliseAdjustment()

void dynadjust::networkadjust::dna_adjust::ValidateandFinaliseAdjustment ( boost::timer::cpu_timer & tot_time )

private

Definition at line 3452 of file dnaadjust.cpp.

{
    isAdjusting_ = false;
 
    if (adjustStatus_ > ADJUST_TEST_FAILED)
        return;
 
    if (IsCancelled())
    {
        adjustStatus_ = ADJUST_CANCELLED;
        return;
    }
 
    if (CurrentIteration() == projectSettings_.a.max_iterations &&
        fabs(maxCorr_) > projectSettings_.a.iteration_threshold)
        adjustStatus_ = ADJUST_MAX_ITERATIONS_EXCEEDED;
 
    // Back up simultaneous rigorous variance estimates (for serialising 
    // to disk at SerialiseAdjustedVarianceMatrices() ), so that executing adjust
    // in report-results mode has access to the latest variance estimates
    switch (projectSettings_.a.adjust_mode)
    {
    case SimultaneousMode:
        v_rigorousVariances_.at(0) = v_normals_.at(0);
        break;
    case Phased_Block_1Mode:
    case PhasedMode:
    default:
        break;
    }
 
    // Print status
    PrintAdjustmentStatus();
    // Compute and print time taken to run adjustment
    PrintAdjustmentTime(tot_time, total_time);
}

References ADJUST_CANCELLED, ADJUST_MAX_ITERATIONS_EXCEEDED, ADJUST_TEST_FAILED, adjustStatus_, CurrentIteration(), isAdjusting_, IsCancelled(), maxCorr_, Phased_Block_1Mode, PhasedMode, PrintAdjustmentStatus(), PrintAdjustmentTime(), projectSettings_, SimultaneousMode, total_time, v_normals_, and v_rigorousVariances_.

Referenced by AdjustPhased(), AdjustPhasedBlock1(), and AdjustSimultaneous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjustmentStatus()

void dynadjust::networkadjust::dna_adjust::PrintAdjustmentStatus ( )

private

Definition at line 3490 of file dnaadjust.cpp.

{
    // print adjustment status
    adj_file << std::endl << OUTPUTLINE << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "SOLUTION";
 
    if (projectSettings_.a.report_mode)
    {
        adj_file << "Printing results of last adjustment only" << std::endl;
        return;
    }
    
    switch (projectSettings_.a.adjust_mode)
    {
    case Phased_Block_1Mode:
        if (adjustStatus_ == ADJUST_SUCCESS)
            adj_file << "Estimates solved for Block 1 only" << std::endl;
        else
            adj_file << "Failed to solve Block 1 estimates" << std::endl;
        break;
    default:
        if (adjustStatus_ == ADJUST_SUCCESS && 
            CurrentIteration() <= projectSettings_.a.max_iterations &&
            fabs(maxCorr_) <= projectSettings_.a.iteration_threshold)
            adj_file << "Converged" << std::endl;
        else
            adj_file << "Failed to converge" << std::endl;
    }
}

References adj_file, ADJUST_SUCCESS, adjustStatus_, CurrentIteration(), maxCorr_, OUTPUTLINE, Phased_Block_1Mode, PRINT_VAR_PAD(), and projectSettings_.

Referenced by AdjustPhasedMultiThread(), and ValidateandFinaliseAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjustmentTime()

void dynadjust::networkadjust::dna_adjust::PrintAdjustmentTime	(	boost::timer::cpu_timer &	time,
		_TIMER_TYPE_	timerType )

private

Definition at line 3521 of file dnaadjust.cpp.

{
    // calculate and print total time
    boost::posix_time::milliseconds ms(boost::posix_time::milliseconds(time.elapsed().wall/MILLI_TO_NANO));
    boost::posix_time::time_duration t(ms);
    
    std::stringstream ss;
    if (t > boost::posix_time::seconds(1))
        ss << boost::posix_time::seconds(static_cast<long>(t.total_seconds()));
    else
        ss << t;
 
    if (timerType == iteration_time)
        adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Elapsed time" << ss.str() << std::endl;
    else
    {
        total_time_ = ms;
        adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Total time" << ss.str() << std::endl << std::endl;
    }
}

References adj_file, iteration_time, MILLI_TO_NANO(), PRINT_VAR_PAD(), and total_time_.

Referenced by AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), and ValidateandFinaliseAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintIteration()

void dynadjust::networkadjust::dna_adjust::PrintIteration ( const UINT32 & iteration )

private

Definition at line 3543 of file dnaadjust.cpp.

{
    std::stringstream iterationMessage;
 
    iterationMessage << std::endl << OUTPUTLINE << std::endl <<
        std::setw(PRINT_VAR_PAD) << std::left << "ITERATION" << iteration << std::endl << std::endl;
 
    adj_file << iterationMessage.str();
 
    if (projectSettings_.g.verbose)
        debug_file << iterationMessage.str();     
}

References adj_file, debug_file, OUTPUTLINE, PRINT_VAR_PAD(), and projectSettings_.

Referenced by AdjustPhased(), AdjustPhasedMultiThread(), and AdjustSimultaneous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ InitialiseAdjustment()

void dynadjust::networkadjust::dna_adjust::InitialiseAdjustment ( )

private

Definition at line 193 of file dnaadjust.cpp.

{
    adj_file << std::endl << "+ Initialising adjustment" << std::endl;
    
    // Confidence interval
    double conf(projectSettings_.a.confidence_interval * 0.01);
    boost::math::normal dist(0.0, 1.0);
    conf += (1.0 - conf) / 2.0;
    criticalValue_ = boost::math::quantile(dist, conf);
 
    potentialOutlierCount_ = 0;
 
    blockCount_ = 1;
    v_blockStationsMap_.resize(blockCount_);
 
    adjustStatus_ = ADJUST_SUCCESS;
    statusMessages_.clear();
    currentBlock_ = 0;
    initialiseIteration();
    
    bstBinaryRecords_.clear();
    bmsBinaryRecords_.clear();
 
    // output precision helpers
    PRECISION_SEC_STN = projectSettings_.o._precision_seconds_stn;
    PRECISION_MTR_STN = projectSettings_.o._precision_metres_stn;
    PRECISION_SEC_MSR = projectSettings_.o._precision_seconds_msr;
    PRECISION_MTR_MSR = projectSettings_.o._precision_metres_msr;
 
    // constraint values
    // cartesian reference frame
    _var_C = projectSettings_.a.fixed_std_dev * projectSettings_.a.fixed_std_dev;     // metres
    _var_F = projectSettings_.a.free_std_dev * projectSettings_.a.free_std_dev;           // metres
    
    // form inverse of variance for fixed stations
    _inv_var_cart_c.redim(3, 3);
    _inv_var_cart_c.put(0, 0, 1./_var_C);
    _inv_var_cart_c.put(1, 1, 1./_var_C);
    _inv_var_cart_c.put(2, 2, 1./_var_C);
 
    // form inverse of variance for free stations
    _inv_var_cart_f.redim(3, 3);
    _inv_var_cart_f.put(0, 0, 1./_var_F);
    _inv_var_cart_f.put(1, 1, 1./_var_F);
    _inv_var_cart_f.put(2, 2, 1./_var_F);
 
}

References _inv_var_cart_c, _inv_var_cart_f, _var_C, _var_F, adj_file, ADJUST_SUCCESS, adjustStatus_, blockCount_, bmsBinaryRecords_, bstBinaryRecords_, criticalValue_, currentBlock_, initialiseIteration(), potentialOutlierCount_, PRECISION_MTR_MSR, PRECISION_MTR_STN, PRECISION_SEC_MSR, PRECISION_SEC_STN, projectSettings_, statusMessages_, and v_blockStationsMap_.

Referenced by PrepareAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetDefaultReferenceFrame()

void dynadjust::networkadjust::dna_adjust::SetDefaultReferenceFrame ( )

private

Definition at line 14040 of file dnaadjust.cpp.

{
    // Capture the datum recorded within binary file meta.
    // Note: One of two applications will have been the last to update the
    //       reference frame in the bst/bms_meta and in every station record:
    //       1. dnaimport
    //       2. dnareftran
    //
    //    * When dnaimport runs, the default reference frame and its epoch is 
    //      set within within the bst/bms_meta, which may or may not be set by 
    //      the user, and is intended to be used to define the datum (ellipsoid 
    //      and epochal coordinate set) to be used throughout all computations.
    //    * For input files which do not specify datum, the datum in bst/bms_meta
    //      will be the same as datum defined for all stations and measurement
    //      records.  For input files which do specify a datum for each station
    //      and measurement, the datum in the bst/bms_meta may be different to what
    //      is set for each station and measurement.  In either case, dnaadjust
    //      takes what is set in the bst/bms_meta.  The user is responsible for
    //      knowing the data and its reference frame.
    //    * If dnareftran has been run, every station and measurement record will
    //      have been transformed to the one frame and epoch. These reference frame
    //      records will be consistent with the bst/bms_meta.
    //    * If the user has not specified an epoch with WGS84, then the epoch will
    //      be set to "time immemorial" being 01.01.1900. Any occurrence of this will
    //      cause output to be set to an empty string ("").
    try {
        // Load binary stations data.  Throws runtime_error on failure.
        dna_io_bst bst;
        bst.load_bst_file_meta(projectSettings_.a.bst_file, bst_meta_);
        datum_.SetDatumFromEpsg(bst_meta_.epsgCode, bst_meta_.epoch);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
}

References bst_meta_, datum_, dynadjust::iostreams::dna_io_bst::load_bst_file_meta(), projectSettings_, and SignalExceptionAdjustment().

Referenced by PrepareAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadNetworkFiles()

void dynadjust::networkadjust::dna_adjust::LoadNetworkFiles ( )

private

Definition at line 14076 of file dnaadjust.cpp.

{
    adj_file << "+ Loading network files" << std::endl;
    
    try {
        // Load binary stations data.  Throws runtime_error on failure.
        dna_io_bst bst;
        bstn_count_ = bst.load_bst_file(projectSettings_.a.bst_file, &bstBinaryRecords_, bst_meta_);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    // Initialise values.
    // Note: The premise underlying the way various programs treat heights is as follows:
    //  - import reads in all heights, but, due to the absence of an attribute or element in
    //    the DynaML schema that states the whether the height system is orthometric or
    //    ellipsoidal, the height system is unknown.
    //  - geoid populates the geoid separation and deflections. It is only when the user
    //    supplies the convert-stn-hts option that it is assumed all heights are orthometric, in
    //    which case the heights are converted to ellipsoidal.
    //  - adjust does not alter station heights, and so adjust assumes currentHeight and 
    //    initialHeight are ellipsoid heights.  Of course, H measurements are converted to R
    //    measurements. If geoid is not run and the user has supplied 
    //    orthometric heights, the adjustment will not produce realistic results.
    //    If a the wrong system (or height) is supplied, one of two things, depending on
    //    the height constraint flag, occur.  For instance, if an orthometric height is supplied,
    //    and geoid information is not available, and the station is Free in the height component,
    //    the error will simply result in a large station height correction.  If the wrong height
    //    is supplied and the station is constrained, then erroneous values will result.
    //  - It is the user's responsibility to ensure the right heights, geoid values and constraints
    //    are supplied.
 
    // Take any additional user-supplied constraints (CCC,CCF,etc) and 
    // apply to binary station records
    ApplyAdditionalConstraints();
 
    vUINT32 v_ISLTemp;
    try {
        // open the asl file. the asl file is required to ensure invalid stations are
        // excluded from the adjustment. invalid stations are those with no measurements.
        dna_io_asl asl;
        asl_count_ = asl.load_asl_file(projectSettings_.s.asl_file, &vAssocStnList_, &v_ISLTemp);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    // remove stations from the stations list that are invalid and update 'true' station count
    RemoveInvalidISLStations(v_ISLTemp);
 
    unknownParams_ = unknownsCount_ = static_cast<UINT32>(v_ISLTemp.size() * 3);
    UINT32 i;
 
    // Copy to v_ISL for simultaneous adjustments
    // For phased adjustments, v_ISL will be populated by LoadSegmentationFile()
    if (projectSettings_.a.adjust_mode == SimultaneousMode)
    {
        // only copy to v_ISL in simultaneous mode
        v_ISL_.push_back(v_ISLTemp);
 
        v_unknownsCount_.clear();
        v_unknownsCount_.push_back(unknownParams_);
        
        // check memory availability for block station map
        if (v_blockStationsMap_.at(0).max_size() <= v_ISL_.at(0).size())
        {
            std::stringstream ss;
            ss << "LoadNetworkFiles(): Could not allocate sufficient memory for blockStationsMap." << std::endl;
            SignalExceptionAdjustment(ss.str(), 0);
        }
 
        // fill block station map, and create pseudo measurement list
        for (i=0; i<v_ISL_.at(0).size(); ++i)
            v_blockStationsMap_.at(0)[v_ISL_.at(0).at(i)] = i;
    }
    
    try {
        // Load binary measurements data.  Throws runtime_error on failure.
        dna_io_bms bms;
        bmsr_count_ = bms.load_bms_file(projectSettings_.a.bms_file, &bmsBinaryRecords_, bms_meta_);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    UINT32 m(0), clusterID(0);
    it_vmsr_t _it_msr;
 
    UINT16 axis(0);
 
    // Consider the following sequence of program calls:
    //  >   import -n unisqr1 uni_sqrstn.xml uni_sqrmsr.xml
    //  >   adjust unisqr1
    //  >   geoid -g ausgeoid09.gsb unisqr1 --convert
    //  >   adjust unisqr1 --output-adj-msr
    //
    // For some reason, these adjustment results don't agree exactly with
    // results from the following:
    //  >   import -n unisqr uni_sqrstn.xml uni_sqrmsr.xml
    //  >   geoid -g ausgeoid09.gsb unisqr --convert
    //  >   adjust unisqr --output-adj-msr
    //
    // Tests on uni_sqrstn.xml and uni_sqrmsr.xml result in the following differences:
    //
    //    dX       | dY      | dZ
    //    ---------+---------+--------
    //     0       | 0.0003  | 0
    //    -0.0006  | 0       |-0.0006
    //
    // Not much of a difference, but different.
    // 
    // Adjustments agree perfectly for GPS-only networks, which indicates that the problem is
    // most likely to do with the application of deflections of the vertical
    
 
    switch (projectSettings_.a.adjust_mode)
    {
    case SimultaneousMode:
        v_CML_.clear();
        v_CML_.push_back(vUINT32(bmsr_count_));
        
        v_measurementCount_.clear();
        v_measurementCount_.push_back(0);
 
        v_measurementVarianceCount_.clear();
        v_measurementVarianceCount_.push_back(0);
 
        // Create measurement tally to determine the measurement
        // types that have been supplied
        for (_it_msr=bmsBinaryRecords_.begin(), i=0, m=0; 
            _it_msr!=bmsBinaryRecords_.end();
            ++_it_msr, ++i)
        {
 
            // Don't include ignored measurements in the CML or 
            // in the measurement count.  Ignored measurements are still 
            // kept in bmsBinaryRecords_, but not in 
            // the list of measurements (i.e. CML) for this adjustment
            if (_it_msr->ignore)
                continue;
 
            // Don't include covariance terms in the CML or 
            // in the measurement count
            if (_it_msr->measStart > zMeas)
                continue;
 
            switch (_it_msr->measType)
            {
            case 'Y':
            case 'X':   
                // Is this an xMeas on a new cluster?
                if (clusterID != _it_msr->clusterID)
                {
                    // Yes, so capture the fist xMeas only
                    v_CML_.at(0).at(m++) = i;
                    clusterID = _it_msr->clusterID;
                }
                
                break;
            default:
                v_CML_.at(0).at(m++) = i;
            }               
 
            if (_it_msr->measType == 'D')
            {
                // The first direction holds number of target directions plus RO.  But
                // since it is possible for target directions to be ignored, take
                // the number of non-ignored measurements (vectorCount2)                                
                // Since directions are reduced to angles, subtract one.
                // Target directions are assigned zero vectorCount1
                if (_it_msr->vectorCount2 > 0)
                {
                    v_measurementCount_.at(0) += _it_msr->vectorCount2 - 1;
                    
                    // The following is needed if the upper triangular variance matrix
                    // for each direction set measurement (as required for propagating)
                    v_measurementVarianceCount_.at(0) += _it_msr->vectorCount2 - 1;
                }
                continue;
            }
 
            switch (_it_msr->measType)
            {
            case 'G':
            case 'X':
            case 'Y':
                // add the 
                v_measurementCount_.at(0)++;
 
                // The following is needed if the upper triangular variance matrix
                // for each GNSS measurement (as is required for propagating)
                v_measurementVarianceCount_.at(0) += 1 + axis++;
 
                if (axis > 2)
                    axis = 0;
                
                continue;
            }
                
            // add the measurement! 
            v_measurementCount_.at(0)++;
            
            // The following is needed if the upper triangular variance matrix
            // for each GNSS measurement (as is required for propagating)
            v_measurementVarianceCount_.at(0)++;
        }
        
        if (m == 0)
        {
            std::stringstream ss;
            ss << "No measurements were found." << std::endl << 
                "  If measurements were successfully loaded on import, ensure that\n  all measurements have not been ignored." << std::endl;
            SignalExceptionAdjustment(ss.str(), 0);
        }
 
        // resize to cater for measurements which were ignored
        if (m != i)
            v_CML_.at(0).resize(m);
 
        // strip all but the start measurements
        RemoveNonMeasurements(0);
 
        measurementParams_ = measurementCount_ = v_measurementCount_.at(0);
    }
 
    v_measurementParams_ = v_measurementCount_;
}

References adj_file, ApplyAdditionalConstraints(), asl_count_, bms_meta_, bmsBinaryRecords_, bmsr_count_, bst_meta_, bstBinaryRecords_, bstn_count_, dynadjust::iostreams::dna_io_asl::load_asl_file(), dynadjust::iostreams::dna_io_bms::load_bms_file(), dynadjust::iostreams::dna_io_bst::load_bst_file(), measurementCount_, measurementParams_, projectSettings_, RemoveInvalidISLStations(), RemoveNonMeasurements(), SignalExceptionAdjustment(), SimultaneousMode, unknownParams_, unknownsCount_, v_blockStationsMap_, v_CML_, v_ISL_, v_measurementCount_, v_measurementParams_, v_measurementVarianceCount_, v_unknownsCount_, vAssocStnList_, and zMeas.

Referenced by PrepareAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CreateMsrToStnTally()

void dynadjust::networkadjust::dna_adjust::CreateMsrToStnTally ( )

private

Definition at line 3259 of file dnaadjust.cpp.

{
    // 1. Load the aml file. The aml file is needed to determine the measurements
    // connected to each station.
    try {
        // Load aml file.  Throws runtime_error on failure.
        dna_io_aml aml;
        aml.load_aml_file(projectSettings_.s.aml_file, &vAssocMsrList_, &bmsBinaryRecords_);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    v_stnmsrTally_.clear();
    v_stnmsrTally_.resize(vAssocStnList_.size());
 
    _it_vasl _it_asl;
    UINT32 i, m, amlIndex, msrCount;
 
    for (_it_asl=vAssocStnList_.begin(), i=0; _it_asl!=vAssocStnList_.end(); ++_it_asl, ++i)
    {
        msrCount = _it_asl->GetAssocMsrCount();
 
        for (m=0; m<msrCount; ++m)
        {
            amlIndex = _it_asl->GetAMLStnIndex() + m;
 
            if (bmsBinaryRecords_.at(vAssocMsrList_.at(amlIndex).bmsr_index).ignore)
                continue;
 
            v_stnmsrTally_.at(i).IncrementMsrType(bmsBinaryRecords_.at(vAssocMsrList_.at(amlIndex).bmsr_index).measType);
        }
 
        v_stnmsrTally_.at(i).TotalCount();
    }
}

References bmsBinaryRecords_, dynadjust::iostreams::dna_io_aml::load_aml_file(), projectSettings_, SignalExceptionAdjustment(), v_stnmsrTally_, vAssocMsrList_, and vAssocStnList_.

Referenced by PrintMeasurementsToStation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustSimultaneous()

void dynadjust::networkadjust::dna_adjust::AdjustSimultaneous ( )

private

Definition at line 3362 of file dnaadjust.cpp.

{
    adjustStatus_ = ADJUST_SUCCESS;
    initialiseIteration();
    
    std::ostringstream ss;
    std::string corr_msg;
    boost::posix_time::milliseconds elapsed_time(boost::posix_time::milliseconds(0));
    boost::timer::cpu_timer it_time, tot_time;
 
    bool iterate;
 
    for (UINT32 i=0; i<projectSettings_.a.max_iterations; ++i)
    {
        if (IsCancelled())
            break;
 
        isIterationComplete_ = false;
 
        blockLargeCorr_ = 0;
        largestCorr_ = 0.0;
 
        // Print the iteration # to adj file
        PrintIteration(incrementIteration());
 
        // Does the user want to print computed measurements on each iteration?
        if (projectSettings_.o._cmp_msr_iteration)
            PrintCompMeasurements(0, "a-priori");      
 
        ss.str("");
        
        it_time.start();
 
        // Least Squares Solution
        // Inverse is only required if:
        //  - This is the first iteration
        //  - The network contains non-GPS measurements, in which an updated 
        //    normals matrix would be available based upon reformed partial
        //    derivatives in the design matrix
        SolveTry(CurrentIteration() < 2 || v_msrTally_.at(0).ContainsNonGPS());
 
        // calculate and print total time
        PrintAdjustmentTime(it_time, iteration_time);
        
        // Add corrections to estimates
        v_estimatedStations_.at(0).add(v_corrections_.at(0));
        
        // Compute and print largest correction
        maxCorr_ = v_corrections_.at(0).compute_maximum_value();
        OutputLargestCorrection(corr_msg);
 
        // update data for messages
        iterationCorrections_.add_message(corr_msg);
        iterationQueue_.push_and_notify(CurrentIteration()); // currentIteration begins at 1, so not zero-indexed
        isIterationComplete_ = true;
        
        // continue iterating?
        iterate = !IsCancelled() && fabs(maxCorr_) > projectSettings_.a.iteration_threshold;
        if (!iterate)
            break;
 
        // Does the user want to print statistics on each iteration?
        if (projectSettings_.o._adj_stat_iteration)
        {
            // Compute network statistics
            ComputeStatisticsOnIteration();
            
            // Print statistics summary to adj file
            PrintStatistics(false);
        }
 
        // Does the user want to print adjusted measurements
        // on each iteration?
        if (projectSettings_.o._adj_msr_iteration)
            ComputeandPrintAdjMsrOnIteration();
 
        // Does the user want to print adjusted station coordinates
        // on each iteration?
        if (projectSettings_.o._adj_stn_iteration)
            // computes geographic coordinates if required
            PrintAdjStations(adj_file, 0, &v_estimatedStations_.at(0), &v_normals_.at(0), 
                false, !v_msrTally_.at(0).ContainsNonGPS(), !v_msrTally_.at(0).ContainsNonGPS(), true, false);
 
        // Update normals and measured-computed matrices for the next iteration.
        UpdateAdjustment(iterate);
    }
 
    ValidateandFinaliseAdjustment(tot_time);
}

References adj_file, ADJUST_SUCCESS, adjustStatus_, blockLargeCorr_, ComputeandPrintAdjMsrOnIteration(), ComputeStatisticsOnIteration(), CurrentIteration(), incrementIteration(), initialiseIteration(), IsCancelled(), isIterationComplete_, iteration_time, iterationCorrections_, iterationQueue_, largestCorr_, maxCorr_, OutputLargestCorrection(), PrintAdjStations(), PrintAdjustmentTime(), PrintCompMeasurements(), PrintIteration(), PrintStatistics(), projectSettings_, SolveTry(), UpdateAdjustment(), v_corrections_, v_estimatedStations_, v_msrTally_, v_normals_, and ValidateandFinaliseAdjustment().

Referenced by AdjustNetwork().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustPhased()

void dynadjust::networkadjust::dna_adjust::AdjustPhased ( )

private

Definition at line 3557 of file dnaadjust.cpp.

{
    initialiseIteration();
 
    std::string corr_msg;
    std::ostringstream ss;
    UINT32 i;
    bool iterate(true);
 
    boost::timer::cpu_timer it_time, tot_time;
        
    // do until convergence criteria is met
    for (i=0; i<projectSettings_.a.max_iterations; ++i)
    {
        if (IsCancelled())
            break;
 
        isIterationComplete_ = false;
 
        blockLargeCorr_ = 0;
        largestCorr_ = 0.0;
        maxCorr_ = 0.0;
 
        // initialise potential outlier count and statistical
        // quantities
        potentialOutlierCount_ = 0;
        chiSquaredStage_ = 0.;
        measurementParams_ = 0;
    
        // Print the iteration # to adj file
        PrintIteration(incrementIteration());
        
        it_time.start();
 
        AdjustPhasedForward();
        if (IsCancelled())
            break;
 
        AdjustPhasedReverseCombine();
        if (IsCancelled())
            break;
 
        // calculate and print total time
        PrintAdjustmentTime(it_time, iteration_time);
        
        // Calculate and print largest adjustment correction and station ID
        OutputLargestCorrection(corr_msg);
        
        iterationCorrections_.add_message(corr_msg);
        iterationQueue_.push_and_notify(CurrentIteration()); // currentIteration begins at 1, so not zero-indexed
        isIterationComplete_ = true;
 
        // Continue iterating?
        iterate = !IsCancelled() && fabs(maxCorr_) > projectSettings_.a.iteration_threshold;
        if (!iterate)
            break;
 
        // Update normals and measured-computed matrices for the next iteration.
        // Similar to PrepareAdjustment, UpdateAdjustment prepares every block
        // in the network so that forward and reverse adjustments can commence
        // at the same time.
        UpdateAdjustment(iterate);  
        if (IsCancelled())
            break;
 
        // Does the user want to print statistics on each iteration?
        if (projectSettings_.o._adj_stat_iteration)
        {
            // Compute network statistics
            ComputeStatisticsOnIteration();
            
            // Print statistics summary to adj file
            PrintStatistics(false);
        }
 
        // Does the user want to print adjusted measurements
        // on each iteration?
        if (projectSettings_.o._adj_msr_iteration)
            ComputeandPrintAdjMsrOnIteration();
    }
 
    chiSquared_ = chiSquaredStage_;
 
    ValidateandFinaliseAdjustment(tot_time);
}

References AdjustPhasedForward(), AdjustPhasedReverseCombine(), blockLargeCorr_, chiSquared_, chiSquaredStage_, ComputeandPrintAdjMsrOnIteration(), ComputeStatisticsOnIteration(), CurrentIteration(), incrementIteration(), initialiseIteration(), IsCancelled(), isIterationComplete_, iteration_time, iterationCorrections_, iterationQueue_, largestCorr_, maxCorr_, measurementParams_, OutputLargestCorrection(), potentialOutlierCount_, PrintAdjustmentTime(), PrintIteration(), PrintStatistics(), projectSettings_, UpdateAdjustment(), and ValidateandFinaliseAdjustment().

Referenced by AdjustNetwork().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustPhasedForward()

void dynadjust::networkadjust::dna_adjust::AdjustPhasedForward ( )

private

Definition at line 3726 of file dnaadjust.cpp.

{   
    forward_ = true;
 
    UINT32 currentBlock(0);
 
    // For staged adjustments, load the first block from mapped memory file
    if (projectSettings_.a.stage)
    {
        DeserialiseBlockFromMappedFile(currentBlock);
        RebuildNormals(currentBlock, __forward__, true, true);
        if (IsCancelled())
            return;
    }
 
    _it_uint32_u32u32_pair begin, end;
    begin = v_msr_block_.begin();
 
    for (currentBlock=0; currentBlock<blockCount_; ++currentBlock)
    {       
        if (IsCancelled())
            break;
 
        SetcurrentBlock(currentBlock);
 
        // Does the user want to print computed measurements?
        if (projectSettings_.o._cmp_msr_iteration)
            PrintCompMeasurements(currentBlock, "a-priori");
        
        if (projectSettings_.o._adj_stn_iteration || projectSettings_.o._cmp_msr_iteration)
        {
            adj_file_mutex.lock();
            adj_file << std::endl << std::left << "Adjusting ";
            if (v_blockMeta_.at(currentBlock)._blockIsolated)
                adj_file << "(isolated) ";
            adj_file << "block " << currentBlock+1;
            if (v_blockMeta_.at(currentBlock)._blockLast || v_blockMeta_.at(currentBlock)._blockIsolated)
                adj_file << " (forward, rigorous)... ";
            else
                adj_file << " (forward, in isolation)... ";
            adj_file_mutex.unlock();
        }
        
        // At this point, whether first iteration or not, if currentBlock is the first block, 
        // the normals will have been initialised.  For all later blocks, the normals will contain
        // the contribution of junction station coordinates and variances from preceding blocks.
        // In either case, the block is ready for adjustment.  Junction station coordinates and 
        // variances are carried forward below
 
        // Least Squares Solution
        SolveTry(true, currentBlock);
 
        // Does the user want to print adjusted measurements
        // on each iteration?
        if (projectSettings_.o._adj_msr_iteration || 
            projectSettings_.o._adj_stn_iteration || 
            projectSettings_.o._cmp_msr_iteration)
            adj_file << " done." << std::endl;
 
        // Add corrections to estimates and update degrees of freedom.
        UpdateEstimatesForward(currentBlock);
 
        // Compute and print adjusted measurements for this 
        // block during an iteration
        if (projectSettings_.o._adj_msr_iteration)
        {
            end = begin + v_CML_.at(currentBlock).size();
            ComputeandPrintAdjMsrBlockOnIteration(currentBlock, v_uint32_u32u32_pair(begin, end), true);
            begin = end;
        }
        
        // Debug and diagnose (if required)
        debug_BlockInformation(currentBlock, (forward_ ? " (Forward)" : " (Reverse)"));
        
        // OK, now shrink matrices back to normal size
        ShrinkForwardMatrices(currentBlock);
 
        // Carry the estimated junction station coordinates and variances 
        // to the next block for applicable blocks only.  For staged
        // Deserialise the next block from mapped files and rebuild 
        // normals
        CarryForwardJunctions(currentBlock, currentBlock+1);
 
        // For staged adjustments, write to disk and unload matrix data
        if (projectSettings_.a.stage)
            // Don't offload last block since the reverse adjustment 
            // will need this block
            if (currentBlock < (blockCount_ - 1))
                OffloadBlockToMappedFile(currentBlock);
    }
}

References __forward__, adj_file, dynadjust::networkadjust::adj_file_mutex, blockCount_, CarryForwardJunctions(), ComputeandPrintAdjMsrBlockOnIteration(), debug_BlockInformation(), DeserialiseBlockFromMappedFile(), forward_, IsCancelled(), OffloadBlockToMappedFile(), PrintCompMeasurements(), projectSettings_, RebuildNormals(), SetcurrentBlock(), ShrinkForwardMatrices(), SolveTry(), UpdateEstimatesForward(), v_blockMeta_, v_CML_, and v_msr_block_.

Referenced by AdjustPhased().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustPhasedReverseCombine()

void dynadjust::networkadjust::dna_adjust::AdjustPhasedReverseCombine ( )

private

Definition at line 4412 of file dnaadjust.cpp.

{
    forward_ = false;
    isCombining_ = false;
    UINT32 currentBlock(blockCount_ - 1);
    UINT32 pseudomsrJSLCount(0);
 
    for (UINT32 block=0; block<blockCount_; ++block, --currentBlock)
    {
        if (IsCancelled())
            break;
 
        SetcurrentBlock(currentBlock);
    
        // If currentBlock is a single block, then there is no need to perform a 
        // reverse adjustment (i.e. continue);
        // Otherwise, if currentBlock is the last block, then this is the 
        // commencement of a reverse run.  In this case, recompute meas-minus-comp,
        // update normals
        if (!PrepareAdjustmentReverse(currentBlock, false))
            continue;       
 
        if (projectSettings_.o._adj_stn_iteration)
        {
            adj_file << std::endl << std::left << "Adjusting block " << currentBlock+1;
            if (!v_blockMeta_.at(currentBlock)._blockFirst)
                adj_file << " (reverse, in isolation)... ";
            else
                // all single blocks and first block of a contiguous list
                adj_file << " (reverse, rigorous)... ";
        }
 
        // At this point, whether first iteration or not, if currentBlock is the last block, 
        // the normals will have been initialised.  For all subsequent blocks, the normals will contain
        // the contribution of junction station coordinates and variances from preceding blocks.
        // In either case, the block is ready for adjustment.  Junction station coordinates and 
        // variances are carried in the reverse direction below
 
        if (projectSettings_.g.verbose > 3)
            debug_file << "In isolation" << std::endl;
 
        // Backup normals prior to inversion for re-use in combination
        // adjustment... only if a combination is required
        BackupNormals(currentBlock, false);
 
        // Least Squares Solution
        SolveTry(true, currentBlock);
 
        if (projectSettings_.o._adj_stn_iteration)
            adj_file << " done." << std::endl;
 
        // Add corrections to estimates.
        // If --output-adj-iter-stat argument is supplied or currentBlock
        // is the first block, then compute geographic coordinates, recompute 
        // meas-minus-computed vector, then print statistics.
        // Output of stats also prints largest correction.
        // If --output-adj-iter-stn argument is supplied, print station coords
        UpdateEstimatesReverse(currentBlock, false);
 
        // Debug and diagnose (if required)
        debug_BlockInformation(currentBlock, "(reverse, in isolation)");
        
        // Carry the estimated junction station coordinates and variances to the next block and
        // combine.  CarryReverseEstimates will return false if currentBlock is the first block
        // or an isolated block.  If estimates can be carried, CarryReverseEstimates updates 
        // geographic coords (if req'd), recomputes meas-minus-comp vector and updates normals for
        // the next block.
        if (CarryReverseJunctions(currentBlock, currentBlock-1, false))
        {           
            // Combination Adjustment 
            //
            // Perform combination on all blocks except the first and last as they will
            // be rigorous from reverse and forward adjustments respectively
            //
            // First, carry the junction station estimates and variances of the next block
            // (obtained during the forward pass).  These were copied to v_junctionEstimatesFwd_
            // and v_junctionVariances_ in CarryStnEstimatesandVariancesForward(..) during
            // the forward pass. 
            if (PrepareAdjustmentCombine(currentBlock, pseudomsrJSLCount, false))
            {
                isCombining_ = true;
                if (projectSettings_.g.verbose > 3)
                    debug_file << "Rigorous" << std::endl;
            
                if (projectSettings_.o._adj_stn_iteration)
                    if (!v_blockMeta_.at(currentBlock)._blockFirst)
                        adj_file << std::endl << std::left << "Adjusting block " << currentBlock+1 << " (reverse, rigorous)... ";
 
                // Least Squares Solution
                SolveTry(true, currentBlock);
 
                if (projectSettings_.o._adj_stn_iteration)
                    adj_file << " done." << std::endl;
 
                // shrink msr-comp and AtVinv by pseudomsrJSLCount from forward pass
                UpdateEstimatesCombine(currentBlock, pseudomsrJSLCount);
 
                // Debug and diagnose (if required)
                debug_BlockInformation(currentBlock, "(reverse, rigorous)");
 
                isCombining_ = false;
 
            }   // if (PrepareAdjustmentCombine(currentBlock, pseudomsrJSLCount, false))  ...  combination adjustment
 
            // shrink msr-comp and AtVinv by JSL count from reverse pass
 
        } // if (CarryReverseJunctions(currentBlock, currentBlock-1, false))
 
        if (projectSettings_.a.stage)
        {
            ComputeAdjMsrBlockOnIteration(currentBlock);
            chiSquaredStage_ += chiSquared_;
            measurementParams_ += v_measurementParams_.at(currentBlock);
        }
 
        // Update the rigorous coordinates
        UpdateEstimatesFinal(currentBlock);
 
        // For staged adjustments, write to disk and unload matrix data
        if (projectSettings_.a.stage)
            OffloadBlockToMappedFile(currentBlock);
 
    }   // for (UINT32 block=0; block<blockCount_; ++block, --currentBlock)
}

References adj_file, BackupNormals(), blockCount_, CarryReverseJunctions(), chiSquared_, chiSquaredStage_, ComputeAdjMsrBlockOnIteration(), debug_BlockInformation(), debug_file, forward_, IsCancelled(), isCombining_, measurementParams_, OffloadBlockToMappedFile(), PrepareAdjustmentCombine(), PrepareAdjustmentReverse(), projectSettings_, SetcurrentBlock(), SolveTry(), UpdateEstimatesCombine(), UpdateEstimatesFinal(), UpdateEstimatesReverse(), v_blockMeta_, and v_measurementParams_.

Referenced by AdjustPhased().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CombinationThreadRequired()

bool dynadjust::networkadjust::dna_adjust::CombinationThreadRequired ( )

private

Definition at line 254 of file dnaadjust-multi.cpp.

{
    for (UINT32 block(0); block<blockCount_; ++block) 
    {
        // Combination adjustment is required if there
        // is at least one intermediate block.
        if (v_blockMeta_.at(block)._blockIntermediate)
            return true;
    }
    return false;
}

References blockCount_, and v_blockMeta_.

Referenced by AdjustPhasedMultiThread().

Here is the caller graph for this function:

◆ AdjustPhasedMultiThread()

void dynadjust::networkadjust::dna_adjust::AdjustPhasedMultiThread ( )

private

Definition at line 93 of file dnaadjust-multi.cpp.

{
    initialiseIteration();
 
    std::string corr_msg;
    std::ostringstream ss;
    UINT32 i;
    bool iterate(true);
 
    boost::posix_time::milliseconds iteration_time(boost::posix_time::milliseconds(0));
    boost::timer::cpu_timer it_time, tot_time;
 
#if defined(__ICC) || defined(__INTEL_COMPILER)     // Intel compiler
    boost::shared_ptr<thread> f, r, c;
    std::vector< boost::shared_ptr<thread> > mt_adjust_threads_sp;
#else
    std::vector<boost::thread> mt_adjust_threads;
#endif  
 
    concurrentAdjustments.resize_runs(blockCount_);
 
    // do until convergence criteria is met
    for (i=0; i<projectSettings_.a.max_iterations; ++i)
    {
        if (IsCancelled())
            break;
 
        SetcurrentBlock(0);
        blockLargeCorr_ = 0;
        largestCorr_ = 0.0;
        maxCorr_ = 0.0;
        // Print the iteration # to adj file.
        // protected write to adj file (not needed here since write to
        // adj file at this stage is via single thread
        PrintIteration(incrementIteration());
 
        concurrentAdjustments.reset_adjustment_runs();     
        concurrentAdjustments.combine_run_stopped();
 
        combineAdjustmentQueue.reset_blocks_coming();
 
        // Forward and reverse threads sequentially adjust all blocks in
        // forward and reverse directions.
#if defined(__ICC) || defined(__INTEL_COMPILER)     // Intel compiler
        f.reset(new thread(adjust_forward_thread(this, boost::ref(fwd_error))));
        mt_adjust_threads_sp.push_back(f);
        r.reset(new thread(adjust_reverse_thread(this, boost::ref(rev_error))));
        mt_adjust_threads_sp.push_back(r);
#else
        mt_adjust_threads.push_back(boost::thread(adjust_forward_thread(this, boost::ref(fwd_error))));
        mt_adjust_threads.push_back(boost::thread(adjust_reverse_thread(this, boost::ref(rev_error))));
#endif          
        
        // Combination thread fires up as many threads as there are cores
        // on the current PC to concurrently combine blocks
#if defined(__ICC) || defined(__INTEL_COMPILER)     // Intel compiler
        if (CombinationThreadRequired())
        {
            c.reset(new thread(adjust_combine_thread(this, boost::ref(cmb_error))));
            mt_adjust_threads_sp.push_back(c);
        }
#else
        if (CombinationThreadRequired())
            mt_adjust_threads.push_back(boost::thread(adjust_combine_thread(this, boost::ref(cmb_error))));
#endif  
 
        // Start the clock
        it_time.start();
 
        // Start the forward, reverse and combine threads, which commences the
        // network adjustment
#if defined(__ICC) || defined(__INTEL_COMPILER)     // Intel compiler
        for_each(mt_adjust_threads_sp.begin(), mt_adjust_threads_sp.end(), boost::mem_fn(&thread::join));
#else
        for_each(mt_adjust_threads.begin(), mt_adjust_threads.end(), boost::mem_fn(&boost::thread::join));
#endif
        // This point is reached when the threads have finished
        iteration_time = boost::posix_time::milliseconds(it_time.elapsed().wall/MILLI_TO_NANO);
 
        //delete mt_adjust_threads;
#if defined(__ICC) || defined(__INTEL_COMPILER)     // Intel compiler
        mt_adjust_threads_sp.clear();
#else
        mt_adjust_threads.clear();
#endif
        
        concurrentAdjustments.combine_run_stopped();
                
        // Were any exceptions thrown?  If so, re-throw and let
        // test stub handle the exception
        if (fwd_error)
            // exception thrown in the forward pass
            boost::rethrow_exception(fwd_error);
        else if (rev_error)
            // exception thrown in the reverse pass
            boost::rethrow_exception(rev_error);
        else if (cmb_error)
            // exception thrown in one of the combination adjustments
            boost::rethrow_exception(cmb_error);
 
        if (IsCancelled())
            break;
 
        ss.str("");
        if (iteration_time > boost::posix_time::seconds(1))
            ss << boost::posix_time::seconds(static_cast<long>(iteration_time.total_seconds()));
        else
            ss << iteration_time;
        // protected write to adj file (not needed here since write to
        // adj file at this stage is via single thread
        adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Elapsed time" << ss.str() << std::endl;
        OutputLargestCorrection(corr_msg);
 
        if (projectSettings_.g.verbose)
            debug_file << concurrentAdjustments.print_adjusted_blocks();
 
        iterationCorrections_.add_message(corr_msg);
        iterationQueue_.push_and_notify(CurrentIteration());             // currentIteration begins at 1, so not zero-indexed
 
        // continue iterating?
        iterate = fabs(maxCorr_) > projectSettings_.a.iteration_threshold;
 
        // Update normals and measured-computed matrices for the next iteration.
        // Similar to PrepareAdjustment, UpdateAdjustment prepares every block
        // in the network so that forward and reverse adjustments can commence
        // at the same time.
        UpdateAdjustment(iterate);
 
        if (!iterate)
            break;
    }
    
    isAdjusting_ = false;
 
    if (adjustStatus_ > ADJUST_TEST_FAILED)
        return;
 
    // This is similar to the check in ValidateandFinaliseAdjustment API for
    // phased single-thread mode. 
    if (IsCancelled())
    {
        adjustStatus_ = ADJUST_CANCELLED;
        return;
    }
 
    if (CurrentIteration() == projectSettings_.a.max_iterations)
        adjustStatus_ = ADJUST_MAX_ITERATIONS_EXCEEDED;
 
    // Print status
    PrintAdjustmentStatus();
    // Compute and print time taken to run adjustment
    PrintAdjustmentTime(tot_time, total_time);
}

References adj_file, ADJUST_CANCELLED, ADJUST_MAX_ITERATIONS_EXCEEDED, ADJUST_TEST_FAILED, adjustStatus_, blockCount_, blockLargeCorr_, dynadjust::networkadjust::cmb_error, CombinationThreadRequired(), dynadjust::networkadjust::combineAdjustmentQueue, dynadjust::networkadjust::concurrentAdjustments, CurrentIteration(), debug_file, dynadjust::networkadjust::fwd_error, incrementIteration(), initialiseIteration(), isAdjusting_, IsCancelled(), iteration_time, iterationCorrections_, iterationQueue_, largestCorr_, maxCorr_, MILLI_TO_NANO(), OutputLargestCorrection(), PRINT_VAR_PAD(), PrintAdjustmentStatus(), PrintAdjustmentTime(), PrintIteration(), projectSettings_, dynadjust::networkadjust::rev_error, SetcurrentBlock(), total_time, and UpdateAdjustment().

Referenced by AdjustNetwork().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustPhasedBlock1()

void dynadjust::networkadjust::dna_adjust::AdjustPhasedBlock1 ( )

private

Definition at line 3646 of file dnaadjust.cpp.

{
    initialiseIteration(1);
    
    std::ostringstream ss;
    std::string corr_msg;
 
    adjustStatus_ = ADJUST_SUCCESS;
    
    maxCorr_ = 0.0;
    blockLargeCorr_ = 0;
    largestCorr_ = 0.0;
        
    adj_file << std::endl << std::endl;
 
    if (projectSettings_.g.verbose)
        debug_file << std::endl << std::endl;
        
    boost::timer::cpu_timer it_time, tot_time;
        
    // Only the reverse adjustment is needed to achieve rigorous
    // estimates for block 1
    AdjustPhasedReverse();
 
    blockLargeCorr_ = 0;
    largestCorr_ = v_corrections_.at(0).maxvalue();
 
    // calculate and print total time
    PrintAdjustmentTime(it_time, iteration_time);  
    
    // Compute and print largest correction for block 1 only
    maxCorr_ = v_corrections_.at(0).compute_maximum_value();
    OutputLargestCorrection(corr_msg);
 
    if (fabs(maxCorr_) > projectSettings_.a.iteration_threshold)
        adjustStatus_ = ADJUST_THRESHOLD_EXCEEDED;
        
    iterationCorrections_.add_message(corr_msg);
    iterationQueue_.push_and_notify(CurrentIteration()); // currentIteration begins at 1, so not zero-indexed
 
    ValidateandFinaliseAdjustment(tot_time);
}

References adj_file, ADJUST_SUCCESS, ADJUST_THRESHOLD_EXCEEDED, AdjustPhasedReverse(), adjustStatus_, blockLargeCorr_, CurrentIteration(), debug_file, initialiseIteration(), iteration_time, iterationCorrections_, iterationQueue_, largestCorr_, maxCorr_, OutputLargestCorrection(), PrintAdjustmentTime(), projectSettings_, v_corrections_, and ValidateandFinaliseAdjustment().

Referenced by AdjustNetwork().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustPhasedReverse()

void dynadjust::networkadjust::dna_adjust::AdjustPhasedReverse ( )

private

Definition at line 4540 of file dnaadjust.cpp.

{
    forward_ = false;
    isCombining_ = false;
    UINT32 currentBlock(blockCount_ - 1);
 
    // For staged adjustments, load the last block from mapped memory file
    if (projectSettings_.a.stage)
        DeserialiseBlockFromMappedFile(currentBlock);
 
    for (UINT32 block=0; block<blockCount_; ++block, --currentBlock)
    {
        if (IsCancelled())
            break;
 
        SetcurrentBlock(currentBlock);
 
        // If currentBlock is a single block, then there is no need to perform a 
        // reverse adjustment (i.e. continue);
        // Otherwise, if currentBlock is the last block, then this is the 
        // commencement of a reverse run.  In this case, recompute meas-minus-comp,
        // update normals
        if (!PrepareAdjustmentReverse(currentBlock, false))
            continue;       
 
        if (projectSettings_.o._adj_stn_iteration)
        {
            adj_file << std::endl << std::left << "Adjusting block " << currentBlock+1;
            if (!v_blockMeta_.at(currentBlock)._blockFirst)
                adj_file << " (reverse, in isolation)... ";
            else
                // all single blocks and first block of a contiguous list
                adj_file << " (reverse, rigorous)... ";
        }
 
        // At this point, whether first iteration or not, if currentBlock is the last block, 
        // the normals will have been initialised.  For all subsequent blocks, the normals will contain
        // the contribution of junction station coordinates and variances from preceding blocks.
        // In either case, the block is ready for adjustment.  Junction station coordinates and 
        // variances are carried in the reverse direction below
        
        if (projectSettings_.g.verbose > 3)
            debug_file << "In isolation" << std::endl;
 
        // Least Squares Solution
        SolveTry(true, currentBlock);
 
        if (projectSettings_.o._adj_stn_iteration)
            adj_file << " done." << std::endl;
        
        // Add corrections to estimates.
        // If --output-adj-iter-stat argument is supplied or currentBlock
        // is the first block, then compute geographic coordinates, recompute 
        // meas-minus-computed vector, then print statistics.
        // Output of stats also prints largest correction.
        // If --output-adj-iter-stn argument is supplied, print station coords
        UpdateEstimatesReverse(currentBlock, false);
 
        // Debug (if required)
        debug_BlockInformation(currentBlock, "(reverse, in isolation)");
 
        // Carry the estimated junction station coordinates and variances to the next block and
        // combine.  CarryReverseEstimates will return false if currentBlock is the first block
        // or an isolated block.  If estimates can be carried, CarryReverseEstimates updates 
        // geographic coords (if req'd), recomputes meas-minus-comp vector and updates normals for
        // the next block.
        CarryReverseJunctions(currentBlock, currentBlock-1, false);
 
        // Update the rigorous coordinates
        UpdateEstimatesFinal(currentBlock);
 
        // For staged adjustments, write to disk and unload matrix data
        if (projectSettings_.a.stage)
            OffloadBlockToMappedFile(currentBlock);
 
    }   // for (UINT32 block=0; block<blockCount_; ++block, --currentBlock)
}

References adj_file, blockCount_, CarryReverseJunctions(), debug_BlockInformation(), debug_file, DeserialiseBlockFromMappedFile(), forward_, IsCancelled(), isCombining_, OffloadBlockToMappedFile(), PrepareAdjustmentReverse(), projectSettings_, SetcurrentBlock(), SolveTry(), UpdateEstimatesFinal(), UpdateEstimatesReverse(), and v_blockMeta_.

Referenced by AdjustPhasedBlock1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ApplyAdditionalConstraints()

void dynadjust::networkadjust::dna_adjust::ApplyAdditionalConstraints ( )

private

Definition at line 14439 of file dnaadjust.cpp.

{
    if (projectSettings_.a.station_constraints.empty())
        return;
 
    // load station map
    v_string_uint32_pair vStnsMap;
    if (projectSettings_.a.map_file.empty())
        projectSettings_.a.map_file = projectSettings_.g.input_folder + FOLDER_SLASH + projectSettings_.g.network_name + ".map";
    LoadStationMap(&vStnsMap, projectSettings_.a.map_file);
 
    std::string constraint;
    vstring constraintStns;
    _it_vstr const_it;
 
    try {
        // Extract constraints from comma delimited string
        SplitDelimitedString<std::string>(
            projectSettings_.a.station_constraints, // the comma delimited string
            std::string(","),                           // the delimiter
            &constraintStns);                       // the respective values
    }
    catch (...) {
        return;
    }
 
    if (projectSettings_.i.apply_discontinuities)
    {
        // Test for whether stations have been renamed, in which case, the
        // look for non empty values in stn.stationNameOrig
        AddDiscontinuitySites(constraintStns);
    }
 
    it_pair_string_vUINT32 it_stnmap_range;
 
    for (const_it=constraintStns.begin(); const_it!=constraintStns.end(); ++const_it) 
    {
        // find this station in the station map
        it_stnmap_range = equal_range(vStnsMap.begin(), vStnsMap.end(), (*const_it), StationNameIDCompareName());
        if (it_stnmap_range.first == it_stnmap_range.second)
        {
            if (projectSettings_.i.apply_discontinuities)
            {
                // It is likely that these stations were renamed during 
                // discontinuity processing, so continue 
                if (++const_it == constraintStns.end())
                    break;
                continue;
            }
 
            std::stringstream ss;
            ss << "The supplied constraint station " << (*const_it) << " is not in the stations map.  Please ensure that " << 
                (*const_it) << " is included in the list of stations." << std::endl;
 
            SignalExceptionAdjustment(ss.str(), 0);
        }
 
        // get constraint
        if (++const_it == constraintStns.end())
            break;
 
        constraint = *const_it;
        // convert to upper case
        str_toupper<int>(constraint);
 
        if (!CDnaStation::IsValidConstraint(constraint))
        {
            std::stringstream ss;
            ss << "The supplied station constraint " << constraint << " is not a valid constraint." << std::endl;
            SignalExceptionAdjustment(ss.str(), 0);
        }
 
        // set constraint
        snprintf(bstBinaryRecords_.at(it_stnmap_range.first->second).stationConst, STN_CONST_WIDTH, "%s", (constraint).c_str());
    }
}

References AddDiscontinuitySites(), bstBinaryRecords_, dynadjust::measurements::CDnaStation::IsValidConstraint(), LoadStationMap(), projectSettings_, SignalExceptionAdjustment(), SplitDelimitedString(), STN_CONST_WIDTH(), and str_toupper().

Referenced by LoadNetworkFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddDiscontinuitySites()

void dynadjust::networkadjust::dna_adjust::AddDiscontinuitySites ( vstring & constraintStns )

private

Definition at line 14305 of file dnaadjust.cpp.

{
    // sort on original name
    std::sort(bstBinaryRecords_.begin(), bstBinaryRecords_.end(), CompareStnOriginalName<station_t, std::string>());
    
    std::pair<it_vstn_t, it_vstn_t> it_stn_range;
    std::string constraint;
 
    _it_vstr const_it;
 
    vstring constraintDiscontStns;
 
    // for every constraint (note every second value will be the constraint code)
    for (const_it=constraintStns.begin(); const_it!=constraintStns.end(); ++const_it) 
    {
        // find this constraint station in the station map
        it_stn_range = equal_range(bstBinaryRecords_.begin(), bstBinaryRecords_.end(), (*const_it), CompareStnOriginalName<station_t, std::string>());
        if (it_stn_range.first == it_stn_range.second)
        {
            // Not in the map.  Get the next one
            continue;
        }
 
        // this constraint station is one of the discontinuity sites.
        // Add the "discontinuity name"
        constraintDiscontStns.push_back(it_stn_range.first->stationName);
        // Add the constraint
        if (++const_it == constraintStns.end())
            break;
        constraintDiscontStns.push_back(*const_it);
    }
 
    // add the constraint discontinuity sites
    constraintStns.insert(constraintStns.end(), constraintDiscontStns.begin(), constraintDiscontStns.end());
 
    // restore original sort order
    std::sort(bstBinaryRecords_.begin(), bstBinaryRecords_.end(), CompareStnName<station_t>());
}

References bstBinaryRecords_.

Referenced by ApplyAdditionalConstraints().

Here is the caller graph for this function:

◆ LoadStationMap()

void dynadjust::networkadjust::dna_adjust::LoadStationMap	(	pv_string_uint32_pair	stnsMap,
		const std::string &	stnmap_file )

private

Definition at line 14517 of file dnaadjust.cpp.

{
    try {
        // Load station map.  Throws runtime_error on failure.
        dna_io_map map;
        map.load_map_file(stnmap_file, stnsMap);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
}

References dynadjust::iostreams::dna_io_map::load_map_file(), and SignalExceptionAdjustment().

Referenced by ApplyAdditionalConstraints(), and InitialiseTypeBUncertainties().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ResizeMatrixVectors()

void dynadjust::networkadjust::dna_adjust::ResizeMatrixVectors ( )

private

Definition at line 14530 of file dnaadjust.cpp.

{
    adj_file << "+ Allocating memory" << std::endl;
    
    switch (projectSettings_.a.adjust_mode)
    {
    case SimultaneousMode:      
        v_parameterStationCount_.resize(blockCount_);
        v_parameterStationList_.resize(blockCount_);
        v_parameterStationList_.at(0) = v_ISL_.at(0);
        break;
    case PhasedMode:
    case Phased_Block_1Mode:
        // Load Segmentation data.  LoadPhasedBlocks() calls LoadSegmentationFile() which
        // and assigns blockCount_
        LoadPhasedBlocks();
 
        v_msrTally_.resize(blockCount_);
 
        v_statSummary_.resize(blockCount_);
        v_pseudoMeasCountFwd_.resize(blockCount_);
        v_sigmaZero_.resize(blockCount_);
        v_chiSquaredUpperLimit_.resize(blockCount_);
        v_chiSquaredLowerLimit_.resize(blockCount_);
        v_passFail_.resize(blockCount_);
 
        v_correctionsR_.resize(blockCount_);
        break;
    default:
        // thrown in LoadNetworkFiles()
        break;
    }
 
    v_msrTally_.resize(blockCount_);
 
    v_design_.resize(blockCount_);
    v_measMinusComp_.resize(blockCount_);
    v_AtVinv_.resize(blockCount_);
    v_normals_.resize(blockCount_);
    v_normalsR_.resize(blockCount_);      // used to back up normals prior to adding parameter stations and junctions
    v_precAdjMsrsFull_.resize(blockCount_);
 
    v_rigorousVariances_.resize(blockCount_);
    v_estimatedStations_.resize(blockCount_);
    v_originalStations_.resize(blockCount_);
    v_corrections_.resize(blockCount_);
 
    if (projectSettings_.a.multi_thread)
        v_normalsRC_.resize(blockCount_);
 
    for (UINT32 block(0); block<blockCount_; ++block)
    {
        // sparse matrix
        v_design_.at(block).matrixType(mtx_sparse);
 
        // lower triangular
        v_normals_.at(block).matrixType(mtx_lower);
        v_normalsR_.at(block).matrixType(mtx_lower);
        v_rigorousVariances_.at(block).matrixType(mtx_lower);
 
        if (projectSettings_.a.adjust_mode == PhasedMode)
        {
            v_junctionVariances_.at(block).matrixType(mtx_lower);
            v_junctionVariancesFwd_.at(block).matrixType(mtx_lower);
        }
    }
    
}

References adj_file, blockCount_, LoadPhasedBlocks(), mtx_lower, mtx_sparse, Phased_Block_1Mode, PhasedMode, projectSettings_, SimultaneousMode, v_AtVinv_, v_chiSquaredLowerLimit_, v_chiSquaredUpperLimit_, v_corrections_, v_correctionsR_, v_design_, v_estimatedStations_, v_ISL_, v_junctionVariances_, v_junctionVariancesFwd_, v_measMinusComp_, v_msrTally_, v_normals_, v_normalsR_, v_normalsRC_, v_originalStations_, v_parameterStationCount_, v_parameterStationList_, v_passFail_, v_precAdjMsrsFull_, v_pseudoMeasCountFwd_, v_rigorousVariances_, v_sigmaZero_, and v_statSummary_.

Referenced by PrepareAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadPhasedBlocks()

void dynadjust::networkadjust::dna_adjust::LoadPhasedBlocks ( )

private

Definition at line 14599 of file dnaadjust.cpp.

{
    LoadSegmentationFile();
 
    if (v_ISL_.size() != v_JSL_.size())
    {
        std::stringstream ss;
        ss << "LoadPhasedBlocks(): An unrecoverable error was encountered when loading the phased adjustment blocks." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
    if (v_JSL_.size() != v_CML_.size())
    {
        std::stringstream ss;
        ss << "LoadPhasedBlocks(): An unrecoverable error was encountered when loading the phased adjustment blocks." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
    
}

References LoadSegmentationFile(), SignalExceptionAdjustment(), v_CML_, v_ISL_, and v_JSL_.

Referenced by ResizeMatrixVectors().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadSegmentationFile()

void dynadjust::networkadjust::dna_adjust::LoadSegmentationFile ( )

private

Definition at line 14837 of file dnaadjust.cpp.

{
    UINT32 blockThreshold, minInnerStns;
 
    try {
        // Load segmentation file.  Throws runtime_error on failure.
        dna_io_seg seg;
        seg.load_seg_file(projectSettings_.a.seg_file, 
            blockCount_, blockThreshold, minInnerStns,
            v_ISL_, v_JSL_, v_CML_,
            true, &bmsBinaryRecords_,
            &v_measurementCount_, &v_unknownsCount_, &v_ContiguousNetList_,
            &v_parameterStationCount_);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    // load segmentation metrics into appropriate vectors
    LoadSegmentationMetrics();
}

References blockCount_, bmsBinaryRecords_, dynadjust::iostreams::dna_io_seg::load_seg_file(), LoadSegmentationMetrics(), projectSettings_, SignalExceptionAdjustment(), v_CML_, v_ContiguousNetList_, v_ISL_, v_JSL_, v_measurementCount_, v_parameterStationCount_, and v_unknownsCount_.

Referenced by LoadPhasedBlocks().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadSegmentationMetrics()

void dynadjust::networkadjust::dna_adjust::LoadSegmentationMetrics ( )

private

Definition at line 14619 of file dnaadjust.cpp.

{
    v_blockMeta_.resize(blockCount_);
    v_blockStationsMap_.resize(blockCount_);
    v_parameterStationList_.resize(blockCount_);
    v_paramStnAppearance_.resize(blockCount_);
    v_junctionVariances_.resize(blockCount_);
    v_junctionVariancesFwd_.resize(blockCount_);
    v_junctionEstimatesFwd_.resize(blockCount_);
    v_junctionEstimatesRev_.resize(blockCount_);
    v_rigorousStations_.resize(blockCount_);
 
    v_measurementVarianceCount_ = v_measurementCount_;
    
    vUINT32 parameterStations;
    UINT32 b, netID(999999), stn, c;
 
    try {
        // read block data
        for (b=0; b<blockCount_; ++b)
        {
            // set Meta
            // If this block has a different ID, then it must be the first.  
            if (netID != v_ContiguousNetList_.at(b))
                v_blockMeta_.at(b)._blockFirst = true;
            else
                v_blockMeta_.at(b)._blockFirst = false;
 
            netID = v_ContiguousNetList_.at(b);
 
            // if this block's ID is different to the next, then it must be the last
            if (b < blockCount_ - 1)
            {
                // the reason why the code in this for loop can't be placed in the preceding loop
                // is because element b+1 is required
                if (v_ContiguousNetList_.at(b) != v_ContiguousNetList_.at(b+1))     
                    v_blockMeta_.at(b)._blockLast = true;
                else
                    v_blockMeta_.at(b)._blockLast = false;
            }
            else // if (b == blockCount_ - 1)       // final block in whole segmentation list?
                v_blockMeta_.at(b)._blockLast = true;
 
            // now, test whether this block is a single block
            if (v_blockMeta_.at(b)._blockFirst && v_blockMeta_.at(b)._blockLast)
                v_blockMeta_.at(b)._blockIsolated = true;
            // or, test whether this block is an intermediate block
            else if (!v_blockMeta_.at(b)._blockFirst && !v_blockMeta_.at(b)._blockLast)
                v_blockMeta_.at(b)._blockIntermediate = true;
 
            // add station map to enable ISL/JSL stations to be referenced according to block
            v_parameterStationList_.at(b) = v_ISL_.at(b);
            v_parameterStationList_.at(b).insert(v_parameterStationList_.at(b).end(),
                v_JSL_.at(b).begin(), v_JSL_.at(b).end());
            std::sort(v_parameterStationList_.at(b).begin(), v_parameterStationList_.at(b).end());
 
            v_paramStnAppearance_.at(b).resize(v_parameterStationList_.at(b).size());
 
            // Add all stations to parameterStations
            parameterStations.insert(parameterStations.end(), v_parameterStationList_.at(b).begin(), v_parameterStationList_.at(b).end());
 
            stn = 0;
 
            // check memory availability for block station map
            if (v_blockStationsMap_.at(b).max_size() <= v_parameterStationCount_.at(b))
            {
                std::stringstream ss;
                ss << "LoadSegmentationMetrics(): Could not allocate sufficient memory for blockStationsMap" << std::endl;
                SignalExceptionAdjustment(ss.str(), 0);
            }
 
            // fill block station map
            for (c=0; c<v_parameterStationCount_.at(b); ++c)
                v_blockStationsMap_.at(b)[v_parameterStationList_.at(b).at(c)] = stn++;   
        }
 
    }
    catch (...) {
        std::stringstream ss;
        ss << "LoadSegmentationMetrics(): An error was encountered when attempting to calculate " << std::endl <<
            "  the segmentation metrics" << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    v_unknownParams_ = v_unknownsCount_;
    v_measurementParams_ = v_measurementCount_;  
 
    // update v_measurementVarianceCount_ if adjusted GNSS measurement
    // variances are to be propagated into another system. Initially, 
    // v_measurementVarianceCount_ is copied from v_measurementCount_ 
    // which contains a count of the rows in the design matrix.  This
    // count represents standard deviations for non-GNSS measurements
    // and the diagonals of GNSS measurement variances. The
    // following code increments the count by 3 for GNSS measurements 
    // so that the count represents an upper triangular matrix,
    // being 6 (xx, xy, xz, yy, yz, zz).
    
    it_vUINT32 _it_block_msr;
    it_vmsr_t _it_msr;
 
    for (b=0; b<blockCount_; ++b)
    {
        for (_it_block_msr=v_CML_.at(b).begin(); 
            _it_block_msr!=v_CML_.at(b).end(); 
            ++_it_block_msr)
        {
            _it_msr = bmsBinaryRecords_.begin() + (*_it_block_msr);
 
            // Is this measurement ignored?
            if (_it_msr->ignore)
                continue;
 
            // When a GNSS measurement is found, add three 
            // elements for X,Y,Z covariance
            switch (_it_msr->measType)
            {
            case 'G':
            case 'X':
            case 'Y':
                
                // Increment by 3 to take count of diagonals
                // to 6, representing upper triangular matrix
                v_measurementVarianceCount_.at(b) += _it_msr->vectorCount1 * 3;
 
                //v_measurementVarianceCount_.at(b) += 3;
                break;
            default:
                continue;
            }
        }
    }
 
 
    // Remove duplicates from the parameterStations list and
    // compute the total unknowns for the entire network    
    strip_duplicates(parameterStations);
 
    // Update "unknowns' count for whole of adjustment
    for_each(parameterStations.begin(), parameterStations.end(),
        [this](const UINT32& stn) {
 
            if (bstBinaryRecords_.at(stn).stationConst[0] == 'C')
                unknownParams_--;
        
            if (bstBinaryRecords_.at(stn).stationConst[1] == 'C')
                unknownParams_--;
        
            if (bstBinaryRecords_.at(stn).stationConst[2] == 'C')
                unknownParams_--;       
    });
 
    if (unknownParams_ == 0 && unknownsCount_ > 0)
        allStationsFixed_ = true;
 
    try {
        // Create station appearance list.  Throws runtime_error on failure.
        dna_io_seg seg;
        seg.create_stn_appearance_list(v_paramStnAppearance_, 
            v_parameterStationList_, vAssocStnList_);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    if (projectSettings_.g.verbose > 1)
    {
        debug_file << std::endl << "Station appearance list" << std::endl;
 
        it_vUINT32_const _it_const;
        it_vstn_appear _it_appear;
 
        for (UINT32 block(0); block!=blockCount_; ++block)
        {
            debug_file << "Block " << block << std::endl;
            debug_file << std::setw(HEADER_20) << "Station" << std::setw(HEADER_20) << "Forward" << std::setw(HEADER_20) << "Reverse" << std::setw(HEADER_20) << " " << std::endl;
 
            for (_it_const=v_parameterStationList_.at(block).begin(),
                _it_appear=v_paramStnAppearance_.at(block).begin();
                _it_appear!=v_paramStnAppearance_.at(block).end();
                ++_it_const, ++_it_appear)
            {
                // station id
                debug_file << std::setw(HEADER_20) << *_it_const;
                // forward
                if (_it_appear->first_appearance_fwd)
                    debug_file << std::setw(HEADER_20) << "true";
                else
                    debug_file << std::setw(HEADER_20) << "false";
                // reverse
                if (_it_appear->first_appearance_rev)
                    debug_file << std::setw(HEADER_20) << "true" << std::endl;
                else
                    debug_file << std::setw(HEADER_20) << "false" << std::endl;
            }
            debug_file << std::endl;
        }
 
        debug_file << std::endl;
    }
 
}

References allStationsFixed_, blockCount_, bmsBinaryRecords_, dynadjust::iostreams::dna_io_seg::create_stn_appearance_list(), debug_file, HEADER_20(), projectSettings_, SignalExceptionAdjustment(), strip_duplicates(), unknownParams_, unknownsCount_, v_blockMeta_, v_blockStationsMap_, v_CML_, v_ContiguousNetList_, v_ISL_, v_JSL_, v_junctionEstimatesFwd_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesFwd_, v_measurementCount_, v_measurementParams_, v_measurementVarianceCount_, v_parameterStationCount_, v_parameterStationList_, v_paramStnAppearance_, v_rigorousStations_, v_unknownParams_, v_unknownsCount_, and vAssocStnList_.

Referenced by LoadSegmentationFile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveInvalidISLStations()

void dynadjust::networkadjust::dna_adjust::RemoveInvalidISLStations ( vUINT32 & v_ISLTemp )

private

Definition at line 14873 of file dnaadjust.cpp.

{
    CompareValidity<CAStationList, UINT32> aslValidityCompareFunc(&vAssocStnList_, FALSE);
    std::sort(v_ISLTemp.begin(), v_ISLTemp.end(), aslValidityCompareFunc);
    erase_if(v_ISLTemp, aslValidityCompareFunc);
    std::sort(v_ISLTemp.begin(), v_ISLTemp.end());
}

References erase_if(), FALSE, and vAssocStnList_.

Referenced by LoadNetworkFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveNonMeasurements()

void dynadjust::networkadjust::dna_adjust::RemoveNonMeasurements ( const UINT32 & block )

private

Definition at line 14883 of file dnaadjust.cpp.

{
    if (v_CML_.at(block).size() < 2)
        return;
    // Strip anything that is not xMeas
    CompareNonMeasStart<measurement_t, UINT32> measstartCompareFunc(&bmsBinaryRecords_, xMeas);
    std::sort(v_CML_.at(block).begin(), v_CML_.at(block).end(), measstartCompareFunc);
    erase_if(v_CML_.at(block), measstartCompareFunc);
    
    // Sort CML on file order (default option)
    CompareMsrFileOrder<measurement_t, UINT32> fileorderCompareFunc(&bmsBinaryRecords_);
    std::sort(v_CML_.at(block).begin(), v_CML_.at(block).end(), fileorderCompareFunc);
    
}

References bmsBinaryRecords_, erase_if(), v_CML_, and xMeas.

Referenced by LoadNetworkFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveDuplicateStations()

void dynadjust::networkadjust::dna_adjust::RemoveDuplicateStations ( vUINT32 & vStns )

private

Definition at line 14860 of file dnaadjust.cpp.

{
    if (vStations.size() < 2)
        return;
    
    strip_duplicates(vStations);
}

References strip_duplicates().

Here is the call graph for this function:

◆ InitialiseTypeBUncertainties()

void dynadjust::networkadjust::dna_adjust::InitialiseTypeBUncertainties ( )

private

Definition at line 14346 of file dnaadjust.cpp.

{
    if (!projectSettings_.o._apply_type_b_global && !projectSettings_.o._apply_type_b_file)
        return;
 
    dna_io_tbu tbu;
 
    // Apply global type B uncertainties to all sites
    if (projectSettings_.o._apply_type_b_global)
    {
        // Load the typeb argument. The typeb argument contains type b uncertainties to be 
        // applied (by default) to all sies
        try {
            
            tbu.load_tbu_argument(projectSettings_.a.type_b_global, typeBUncertaintyGlobal_);
        }
        catch (const std::runtime_error& e) {
            SignalExceptionAdjustment(e.what(), 0);
        }
        catch (...) {
            return;
        }       
    }
 
    // Apply (or overwrite) type B uncertainties to specific sites
    if (projectSettings_.o._apply_type_b_file)
    {
        // load station map
        v_string_uint32_pair vStnsMap;
        if (projectSettings_.a.map_file.empty())
            projectSettings_.a.map_file = projectSettings_.g.input_folder + FOLDER_SLASH + projectSettings_.g.network_name + ".map";
        LoadStationMap(&vStnsMap, projectSettings_.a.map_file);
 
        // Load the typeb file. The typeb file contains site-specific type b uncertainties
        try {
 
            tbu.load_tbu_file(projectSettings_.a.type_b_file, v_typeBUncertaintiesLocal_, vStnsMap);
            std::sort(v_typeBUncertaintiesLocal_.begin(), v_typeBUncertaintiesLocal_.end());
 
            // reduce to the cartesian reference frame
            tbu.reduce_uncertainties_local(v_typeBUncertaintiesLocal_, bstBinaryRecords_);
        }
        catch (const std::ifstream::failure& f) {
            SignalExceptionAdjustment(f.what(), 0);
        }
        catch (const std::runtime_error& e) {
            SignalExceptionAdjustment(e.what(), 0);
        }
    }
 
    // Now, set the method of application
    UINT32 stn(0);
    it_pair_type_b_uncertainty it_tbu;
 
    // Create a vector of elements (with a size equal to the station count) that manages how
    // type b uncertainties are to be applied.
    v_typeBUncertaintyMethod_.resize(bstBinaryRecords_.size());
    // Create a map between station ID and the type b uncertainties vector
    v_stationTypeBMap_.resize(bstBinaryRecords_.size());
 
    for (stn = 0; stn < bstBinaryRecords_.size(); ++stn)
    {
        v_typeBUncertaintyMethod_.at(stn).station_id = stn;
        v_stationTypeBMap_.at(stn).first = stn;
        v_stationTypeBMap_.at(stn).second = 0;
 
        // set method to be global by default
        if (projectSettings_.o._apply_type_b_global)
        {
            v_typeBUncertaintyMethod_.at(stn).apply = true;
            v_typeBUncertaintyMethod_.at(stn).method = type_b_global;
        }
 
        // overwrite global with site specific type b
        if (projectSettings_.o._apply_type_b_file)
        {
            it_tbu = equal_range(v_typeBUncertaintiesLocal_.begin(), v_typeBUncertaintiesLocal_.end(), 
                stn, CompareTypeBStationID<UINT32, type_b_uncertainty>());
            if (it_tbu.first != it_tbu.second)
            {
                v_typeBUncertaintyMethod_.at(stn).apply = true;
                v_typeBUncertaintyMethod_.at(stn).method = type_b_local;
 
                // map the local uncertainty index
                v_stationTypeBMap_.at(stn).second = static_cast<UINT32>(std::distance(v_typeBUncertaintiesLocal_.begin(), it_tbu.first));
            }
        }
 
    }
}

References bstBinaryRecords_, dynadjust::iostreams::dna_io_tbu::load_tbu_argument(), dynadjust::iostreams::dna_io_tbu::load_tbu_file(), LoadStationMap(), projectSettings_, dynadjust::iostreams::dna_io_tbu::reduce_uncertainties_local(), SignalExceptionAdjustment(), dynadjust::iostreams::type_b_global, dynadjust::iostreams::type_b_local, typeBUncertaintyGlobal_, v_stationTypeBMap_, v_typeBUncertaintiesLocal_, and v_typeBUncertaintyMethod_.

Referenced by PrepareAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SortMeasurementsbyType()

void dynadjust::networkadjust::dna_adjust::SortMeasurementsbyType ( v_uint32_u32u32_pair & msr_block )

private

Definition at line 14899 of file dnaadjust.cpp.

{
    if (msr_block.size() < 2)
        return;
    CompareMeasType_PairFirst<measurement_t, UINT32> meastypeCompareFunc(&bmsBinaryRecords_);
    std::sort(msr_block.begin(), msr_block.end(), meastypeCompareFunc);
}

References bmsBinaryRecords_.

Referenced by PrintAdjMeasurements().

Here is the caller graph for this function:

◆ SortMeasurementsbyFromStn()

void dynadjust::networkadjust::dna_adjust::SortMeasurementsbyFromStn ( v_uint32_u32u32_pair & msr_block )

private

Definition at line 14908 of file dnaadjust.cpp.

{
    if (msr_block.size() < 2)
        return;
    CompareMeasFromStn_PairFirst<measurement_t, UINT32> measfromstnCompareFunc(&bmsBinaryRecords_);
    std::sort(msr_block.begin(), msr_block.end(), measfromstnCompareFunc);
}

References bmsBinaryRecords_.

Referenced by PrintAdjMeasurements().

Here is the caller graph for this function:

◆ SortMeasurementsbyToStn()

void dynadjust::networkadjust::dna_adjust::SortMeasurementsbyToStn ( v_uint32_u32u32_pair & msr_block )

private

Definition at line 14917 of file dnaadjust.cpp.

{
    if (msr_block.size() < 2)
        return;
    CompareMeasToStn_PairFirst<measurement_t, UINT32> meastostnCompareFunc(&bmsBinaryRecords_);
    std::sort(msr_block.begin(), msr_block.end(), meastostnCompareFunc);
}

References bmsBinaryRecords_.

Referenced by PrintAdjMeasurements().

Here is the caller graph for this function:

◆ SortMeasurementsbyValue()

void dynadjust::networkadjust::dna_adjust::SortMeasurementsbyValue ( v_uint32_u32u32_pair & msr_block )

private

Definition at line 14926 of file dnaadjust.cpp.

{
    if (msr_block.size() < 2)
        return;
    CompareMeasValue_PairFirst<measurement_t, UINT32> measvalueCompareFunc(&bmsBinaryRecords_);
    std::sort(msr_block.begin(), msr_block.end(), measvalueCompareFunc);
}

References bmsBinaryRecords_.

Referenced by PrintAdjMeasurements().

Here is the caller graph for this function:

◆ SortMeasurementsbyResidual()

void dynadjust::networkadjust::dna_adjust::SortMeasurementsbyResidual ( v_uint32_u32u32_pair & msr_block )

private

Definition at line 14935 of file dnaadjust.cpp.

{
    if (msr_block.size() < 2)
        return;
    CompareMeasResidual_PairFirst<measurement_t, UINT32> measresidualCompareFunc(&bmsBinaryRecords_);
    std::sort(msr_block.begin(), msr_block.end(), measresidualCompareFunc);
}

References bmsBinaryRecords_.

Referenced by PrintAdjMeasurements().

Here is the caller graph for this function:

◆ SortMeasurementsbyAdjSD()

void dynadjust::networkadjust::dna_adjust::SortMeasurementsbyAdjSD ( v_uint32_u32u32_pair & msr_block )

private

Definition at line 14944 of file dnaadjust.cpp.

{
    if (msr_block.size() < 2)
        return;
    CompareMeasAdjSD_PairFirst<measurement_t, UINT32> measadjsdCompareFunc(&bmsBinaryRecords_);
    std::sort(msr_block.begin(), msr_block.end(), measadjsdCompareFunc);
}

References bmsBinaryRecords_.

Referenced by PrintAdjMeasurements().

Here is the caller graph for this function:

◆ SortMeasurementsbyNstat()

void dynadjust::networkadjust::dna_adjust::SortMeasurementsbyNstat ( v_uint32_u32u32_pair & msr_block )

private

Definition at line 14953 of file dnaadjust.cpp.

{
    if (msr_block.size() < 2)
        return;
    CompareMeasNstat_PairFirst<measurement_t, UINT32> measnstatCompareFunc(&bmsBinaryRecords_);
    std::sort(msr_block.begin(), msr_block.end(), measnstatCompareFunc);
}

References bmsBinaryRecords_.

Referenced by PrintAdjMeasurements().

Here is the caller graph for this function:

◆ SortStationsbyFileOrder()

void dynadjust::networkadjust::dna_adjust::SortStationsbyFileOrder ( vUINT32 & v_blockStations )

private

Definition at line 10019 of file dnaadjust.cpp.

{
    CompareStnFileOrder<station_t, UINT32> stnorderCompareFunc(&bstBinaryRecords_);
    std::sort(v_blockStations.begin(), v_blockStations.end(), stnorderCompareFunc);
}

References bstBinaryRecords_.

Referenced by PrintAdjStations(), PrintCorStations(), and PrintPosUncertainties().

Here is the caller graph for this function:

◆ SortStationsbyID()

void dynadjust::networkadjust::dna_adjust::SortStationsbyID ( vUINT32 & v_blockStations )

private

Definition at line 10025 of file dnaadjust.cpp.

{
    std::sort(v_blockStations.begin(), v_blockStations.end());
}

Referenced by PrintAdjStations(), PrintCorStations(), and PrintPosUncertainties().

Here is the caller graph for this function:

◆ SetRegionOffsets()

void dynadjust::networkadjust::dna_adjust::SetRegionOffsets	(	const UINT32 &	block,
		const int	file_count = 0,
			... )

private

Definition at line 60 of file dnaadjust-stage.cpp.

{
    if (file_count == 0)
    {
        // deserialise all.  That is, call this function again, but with 
        // arguments for all files
        SetRegionOffsets(block, 12, 
            sf_normals_r, sf_meas_minus_comp,
            sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
            sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
            sf_rigorous_vars, sf_prec_adj_msrs, sf_corrections);
        return;
    }
 
    va_list vlist;
    va_start(vlist, file_count);
 
    for (UINT16 file(0); file<file_count; ++file)
    {
        switch (va_arg(vlist, int))
        {
        case sf_normals_r:
            normalsR_map_.addblockMapRegion(block_map_t(v_normalsR_.at(block).get_size()));
            SetRegionOffset(normalsR_map_);
            break;
        case sf_meas_minus_comp:
            measMinusComp_map_.addblockMapRegion(block_map_t(v_measMinusComp_.at(block).get_size()));
            SetRegionOffset(measMinusComp_map_);
            break;
        case sf_estimated_stns:
            estimatedStations_map_.addblockMapRegion(block_map_t(v_estimatedStations_.at(block).get_size()));
            SetRegionOffset(estimatedStations_map_);
            break;
        case sf_original_stns:
            originalStations_map_.addblockMapRegion(block_map_t(v_originalStations_.at(block).get_size()));
            SetRegionOffset(originalStations_map_);
            break;
        case sf_rigorous_stns:
            rigorousStations_map_.addblockMapRegion(block_map_t(v_rigorousStations_.at(block).get_size()));
            SetRegionOffset(rigorousStations_map_);
            break;
        case sf_junction_vars:
            junctionVariances_map_.addblockMapRegion(block_map_t(v_junctionVariances_.at(block).get_size()));
            SetRegionOffset(junctionVariances_map_);
            break;
        case sf_junction_vars_f:
            junctionVariancesFwd_map_.addblockMapRegion(block_map_t(v_junctionVariancesFwd_.at(block).get_size()));
            SetRegionOffset(junctionVariancesFwd_map_);
            break;
        case sf_junction_ests_f:
            junctionEstimatesFwd_map_.addblockMapRegion(block_map_t(v_junctionEstimatesFwd_.at(block).get_size()));
            SetRegionOffset(junctionEstimatesFwd_map_);
            break;
        case sf_junction_ests_r:
            junctionEstimatesRev_map_.addblockMapRegion(block_map_t(v_junctionEstimatesRev_.at(block).get_size()));
            SetRegionOffset(junctionEstimatesRev_map_);
            break;
        case sf_rigorous_vars:
            rigorousVariances_map_.addblockMapRegion(block_map_t(v_rigorousVariances_.at(block).get_size()));
            SetRegionOffset(rigorousVariances_map_);
            break;
        case sf_prec_adj_msrs:
            precAdjMsrs_map_.addblockMapRegion(block_map_t(v_precAdjMsrsFull_.at(block).get_size()));
            SetRegionOffset(precAdjMsrs_map_);
            break;
        case sf_corrections:
            corrections_map_.addblockMapRegion(block_map_t(v_corrections_.at(block).get_size()));
            SetRegionOffset(corrections_map_);
            break;
        }
    }
    va_end(vlist);
}

References corrections_map_, estimatedStations_map_, junctionEstimatesFwd_map_, junctionEstimatesRev_map_, junctionVariances_map_, junctionVariancesFwd_map_, measMinusComp_map_, normalsR_map_, originalStations_map_, precAdjMsrs_map_, rigorousStations_map_, rigorousVariances_map_, SetRegionOffset(), SetRegionOffsets(), sf_corrections, sf_estimated_stns, sf_junction_ests_f, sf_junction_ests_r, sf_junction_vars, sf_junction_vars_f, sf_meas_minus_comp, sf_normals_r, sf_original_stns, sf_prec_adj_msrs, sf_rigorous_stns, sf_rigorous_vars, v_corrections_, v_estimatedStations_, v_junctionEstimatesFwd_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesFwd_, v_measMinusComp_, v_normalsR_, v_originalStations_, v_precAdjMsrsFull_, v_rigorousStations_, and v_rigorousVariances_.

Referenced by DeSerialiseAdjustedVarianceMatrices(), PrepareAdjustmentBlock(), PrepareMappedRegions(), SerialiseAdjustedVarianceMatrices(), and SetRegionOffsets().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetRegionOffset()

void dynadjust::networkadjust::dna_adjust::SetRegionOffset ( vmat_file_map & file_map )

private

Definition at line 135 of file dnaadjust-stage.cpp.

{
    // Get iterator to the second last mapped region
    _it_block_map _it_bmap_prev(file_map.vblockMapRegions_.end() - 1);
    if (_it_bmap_prev == file_map.vblockMapRegions_.begin())
        return;
    _it_bmap_prev--;
    // Get iterator to the last mapped region
    _it_block_map _it_bmap(file_map.vblockMapRegions_.end() - 1);
    // Set region offset for the last mapped region
    _it_bmap->SetRegionOffset(_it_bmap_prev->GetCumulativeRegionOffset());  
}

References dynadjust::memory::vmat_file_map::vblockMapRegions_.

Referenced by SetRegionOffsets().

Here is the caller graph for this function:

◆ SetMapRegions()

void dynadjust::networkadjust::dna_adjust::SetMapRegions	(	const int	file_count = 0,
			... )

private

Definition at line 544 of file dnaadjust-stage.cpp.

{
    if (file_count == 0)
    {
        // serialise all.  That is, call this function again, but with 
        // arguments for all files
        SetMapRegions(12, 
            sf_normals_r, sf_meas_minus_comp,
            sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
            sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
            sf_rigorous_vars, sf_prec_adj_msrs, sf_corrections);
        return;
    }
 
    va_list vlist;
    va_start(vlist, file_count);    
 
    for (UINT16 file(0); file<file_count; ++file)
    {
        switch (va_arg(vlist, int))
        {
        case sf_normals_r:
 
            // Create file map, and associate the regions with the normals blocks in the file
            normalsR_map_.CreateFileMap();     // File path set in OpenStageFileStreams
            for_each(
                normalsR_map_.vblockMapRegions_.begin(), 
                normalsR_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(normalsR_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_meas_minus_comp:
 
            // Create file map, and associate the regions with the normals blocks in the file
            measMinusComp_map_.CreateFileMap();       // File path set in OpenStageFileStreams
            for_each(
                measMinusComp_map_.vblockMapRegions_.begin(), 
                measMinusComp_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(measMinusComp_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_estimated_stns:
 
            // Create file map, and associate the regions with the normals blocks in the file
            estimatedStations_map_.CreateFileMap();       // File path set in OpenStageFileStreams
            for_each(
                estimatedStations_map_.vblockMapRegions_.begin(), 
                estimatedStations_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(estimatedStations_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_original_stns:
 
            // Create file map, and associate the regions with the normals blocks in the file
            originalStations_map_.CreateFileMap();     // File path set in OpenStageFileStreams
            for_each(
                originalStations_map_.vblockMapRegions_.begin(), 
                originalStations_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(originalStations_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_rigorous_stns:
 
            // Create file map, and associate the regions with the normals blocks in the file
            rigorousStations_map_.CreateFileMap();     // File path set in OpenStageFileStreams
            for_each(
                rigorousStations_map_.vblockMapRegions_.begin(), 
                rigorousStations_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(rigorousStations_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_junction_vars:
 
            // Create file map, and associate the regions with the normals blocks in the file
            junctionVariances_map_.CreateFileMap();       // File path set in OpenStageFileStreams
            for_each(
                junctionVariances_map_.vblockMapRegions_.begin(), 
                junctionVariances_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(junctionVariances_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_junction_vars_f:
 
            // Create file map, and associate the regions with the normals blocks in the file
            junctionVariancesFwd_map_.CreateFileMap();     // File path set in OpenStageFileStreams
            for_each(
                junctionVariancesFwd_map_.vblockMapRegions_.begin(), 
                junctionVariancesFwd_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(junctionVariancesFwd_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_junction_ests_f:
 
            // Create file map, and associate the regions with the normals blocks in the file
            junctionEstimatesFwd_map_.CreateFileMap();     // File path set in OpenStageFileStreams
            for_each(
                junctionEstimatesFwd_map_.vblockMapRegions_.begin(), 
                junctionEstimatesFwd_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(junctionEstimatesFwd_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_junction_ests_r:
 
            // Create file map, and associate the regions with the normals blocks in the file
            junctionEstimatesRev_map_.CreateFileMap();     // File path set in OpenStageFileStreams
            for_each(
                junctionEstimatesRev_map_.vblockMapRegions_.begin(), 
                junctionEstimatesRev_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(junctionEstimatesRev_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_rigorous_vars:
 
            // Create file map, and associate the regions with the normals blocks in the file
            rigorousVariances_map_.CreateFileMap();       // File path set in OpenStageFileStreams
            for_each(
                rigorousVariances_map_.vblockMapRegions_.begin(), 
                rigorousVariances_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(rigorousVariances_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_prec_adj_msrs:
 
            // Create file map, and associate the regions with the normals blocks in the file
            precAdjMsrs_map_.CreateFileMap();       // File path set in OpenStageFileStreams
            for_each(
                precAdjMsrs_map_.vblockMapRegions_.begin(), 
                precAdjMsrs_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(precAdjMsrs_map_.getFileMapPtr());
                }
            );
 
            break;
        case sf_corrections:
 
            // Create file map, and associate the regions with the normals blocks in the file
            corrections_map_.CreateFileMap();       // File path set in OpenStageFileStreams
            for_each(
                corrections_map_.vblockMapRegions_.begin(), 
                corrections_map_.vblockMapRegions_.end(), 
                [this] (block_map_t& block_map) {           // use lambda expression
                    block_map.MapRegion(corrections_map_.getFileMapPtr());
                }
            );
 
            break;
        }
    }
    va_end(vlist);
}

References corrections_map_, estimatedStations_map_, junctionEstimatesFwd_map_, junctionEstimatesRev_map_, junctionVariances_map_, junctionVariancesFwd_map_, measMinusComp_map_, normalsR_map_, originalStations_map_, precAdjMsrs_map_, rigorousStations_map_, rigorousVariances_map_, SetMapRegions(), sf_corrections, sf_estimated_stns, sf_junction_ests_f, sf_junction_ests_r, sf_junction_vars, sf_junction_vars_f, sf_meas_minus_comp, sf_normals_r, sf_original_stns, sf_prec_adj_msrs, sf_rigorous_stns, and sf_rigorous_vars.

Referenced by DeSerialiseAdjustedVarianceMatrices(), PrepareAdjustment(), and SetMapRegions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareMemoryMapRegions()

void dynadjust::networkadjust::dna_adjust::PrepareMemoryMapRegions	(	const UINT32 &	block,
		const int	file_count = 0,
			... )

private

Definition at line 727 of file dnaadjust-stage.cpp.

{
    if (file_count == 0)
    {
        // serialise all.  That is, call this function again, but with 
        // arguments for all files
        PrepareMemoryMapRegions(block, 12, 
            sf_normals_r, sf_meas_minus_comp,
            sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
            sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
            sf_rigorous_vars, sf_prec_adj_msrs, sf_corrections);
        return;
    }
 
    va_list vlist;
    va_start(vlist, file_count);    
 
    for (UINT16 file(0); file<file_count; ++file)
    {
        switch (va_arg(vlist, int))
        {
        case sf_normals_r:
 
            // Create file map, and associate the regions with the normals blocks in the file
            normalsR_map_.CreateFileMap();             // File path set in OpenStageFileStreams
            normalsR_map_.MapRegion(block);
 
            break;
        case sf_meas_minus_comp:
 
            // Create file map, and associate the regions with the normals blocks in the file
            measMinusComp_map_.CreateFileMap();           // File path set in OpenStageFileStreams
            measMinusComp_map_.MapRegion(block);
        
            break;
        case sf_estimated_stns:
 
            // Create file map, and associate the regions with the normals blocks in the file
            estimatedStations_map_.CreateFileMap();       // File path set in OpenStageFileStreams
            estimatedStations_map_.MapRegion(block);
        
            break;
        case sf_original_stns:
 
            // Create file map, and associate the regions with the normals blocks in the file
            originalStations_map_.CreateFileMap();     // File path set in OpenStageFileStreams
            originalStations_map_.MapRegion(block);
        
            break;
        case sf_rigorous_stns:
 
            // Create file map, and associate the regions with the normals blocks in the file
            rigorousStations_map_.CreateFileMap();     // File path set in OpenStageFileStreams
            rigorousStations_map_.MapRegion(block);
        
            break;
        case sf_junction_vars:
 
            // Create file map, and associate the regions with the normals blocks in the file
            junctionVariances_map_.CreateFileMap();       // File path set in OpenStageFileStreams
            junctionVariances_map_.MapRegion(block);
        
            break;
        case sf_junction_vars_f:
 
            // Create file map, and associate the regions with the normals blocks in the file
            junctionVariancesFwd_map_.CreateFileMap(); // File path set in OpenStageFileStreams
            junctionVariancesFwd_map_.MapRegion(block);
        
            break;
        case sf_junction_ests_f:
 
            // Create file map, and associate the regions with the normals blocks in the file
            junctionEstimatesFwd_map_.CreateFileMap(); // File path set in OpenStageFileStreams
            junctionEstimatesFwd_map_.MapRegion(block);
        
            break;
        case sf_junction_ests_r:
 
            // Create file map, and associate the regions with the normals blocks in the file
            junctionEstimatesRev_map_.CreateFileMap(); // File path set in OpenStageFileStreams
            junctionEstimatesRev_map_.MapRegion(block);
        
            break;
        case sf_rigorous_vars:
 
            // Create file map, and associate the regions with the normals blocks in the file
            rigorousVariances_map_.CreateFileMap();       // File path set in OpenStageFileStreams
            rigorousVariances_map_.MapRegion(block);
        
            break;
        case sf_prec_adj_msrs:
 
            // Create file map, and associate the regions with the normals blocks in the file
            precAdjMsrs_map_.CreateFileMap();           // File path set in OpenStageFileStreams
            precAdjMsrs_map_.MapRegion(block);
        
            break;
        case sf_corrections:
 
            // Create file map, and associate the regions with the normals blocks in the file
            corrections_map_.CreateFileMap();           // File path set in OpenStageFileStreams
            corrections_map_.MapRegion(block);
 
            break;
        }
    }
    va_end(vlist);
}

References corrections_map_, estimatedStations_map_, junctionEstimatesFwd_map_, junctionEstimatesRev_map_, junctionVariances_map_, junctionVariancesFwd_map_, measMinusComp_map_, normalsR_map_, originalStations_map_, precAdjMsrs_map_, PrepareMemoryMapRegions(), rigorousStations_map_, rigorousVariances_map_, sf_corrections, sf_estimated_stns, sf_junction_ests_f, sf_junction_ests_r, sf_junction_vars, sf_junction_vars_f, sf_meas_minus_comp, sf_normals_r, sf_original_stns, sf_prec_adj_msrs, sf_rigorous_stns, and sf_rigorous_vars.

Referenced by DeSerialiseAdjustedVarianceMatrices(), PrepareMappedRegions(), and PrepareMemoryMapRegions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OffloadBlockToDisk()

void dynadjust::networkadjust::dna_adjust::OffloadBlockToDisk ( const UINT32 & block )

private

Definition at line 838 of file dnaadjust-stage.cpp.

{
    // Write block matrix data to disk
    SerialiseBlockToDisk(block);
 
    // Unload block matrix data from memory
    UnloadBlock(block);
}

References SerialiseBlockToDisk(), and UnloadBlock().

Referenced by PrepareAdjustmentBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OffloadBlockToMappedFile()

void dynadjust::networkadjust::dna_adjust::OffloadBlockToMappedFile ( const UINT32 & block )

private

Definition at line 848 of file dnaadjust-stage.cpp.

{
    // Write block matrix data to disk
    SerialiseBlockToMappedFile(block);
 
    // Unload block matrix data from memory
    UnloadBlock(block);
}

References SerialiseBlockToMappedFile(), and UnloadBlock().

Referenced by AdjustPhasedForward(), AdjustPhasedReverse(), AdjustPhasedReverseCombine(), and PrepareAdjustmentReverse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SerialiseBlockToDisk()

void dynadjust::networkadjust::dna_adjust::SerialiseBlockToDisk ( const UINT32 & block )

private

Definition at line 858 of file dnaadjust-stage.cpp.

{
    // Write block matrix data to disk
    try {
        // Normals - reverse
        f_normalsR_ << v_normalsR_.at(block);                         // ...neqr.mtx      
        // Measured minus computed
        f_measMinusComp_ << v_measMinusComp_.at(block);                 // ...mmc.mtx       
        // Estimated stations
        f_estimatedStations_ << v_estimatedStations_.at(block);         // ...est.mtx
        // original stations
        f_originalStations_ << v_originalStations_.at(block);         // ...ost.mtx
        // Rigorous stations
        f_rigorousStations_ << v_rigorousStations_.at(block);         // ...rst.mtx
        // Junction variances
        f_junctionVariances_ << v_junctionVariances_.at(block);         // ...jva.mtx
        // Junction variances forward
        f_junctionVariancesFwd_ << v_junctionVariancesFwd_.at(block); // ...jvf.mtx
        // Junction estimates forward
        f_junctionEstimatesFwd_ << v_junctionEstimatesFwd_.at(block); // ...jef.mtx
        // Junction estimates reverse
        f_junctionEstimatesRev_ << v_junctionEstimatesRev_.at(block); // ...jer.mtx
        // Rigorous variances
        f_rigorousVariances_ << v_rigorousVariances_.at(block);         // ...rva.mtx
        // Precision adjusted measurements
        f_precAdjMsrs_ << v_precAdjMsrsFull_.at(block);                 // ...pam.mtx
        // Corrections
        f_corrections_ << v_corrections_.at(block);                     // ...cor.mtx
    }
    catch (...) {
        std::stringstream ss;
        ss << "SerialiseBlockToDisk(): An error was encountered when writing matrix data to disk." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }   
}

References f_corrections_, f_estimatedStations_, f_junctionEstimatesFwd_, f_junctionEstimatesRev_, f_junctionVariances_, f_junctionVariancesFwd_, f_measMinusComp_, f_normalsR_, f_originalStations_, f_precAdjMsrs_, f_rigorousStations_, f_rigorousVariances_, SignalExceptionAdjustment(), v_corrections_, v_estimatedStations_, v_junctionEstimatesFwd_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesFwd_, v_measMinusComp_, v_normalsR_, v_originalStations_, v_precAdjMsrsFull_, v_rigorousStations_, and v_rigorousVariances_.

Referenced by OffloadBlockToDisk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SerialiseBlockToMappedFile()

void dynadjust::networkadjust::dna_adjust::SerialiseBlockToMappedFile	(	const UINT32 &	block,
		const int	file_count = 0,
			... )

private

Definition at line 238 of file dnaadjust-stage.cpp.

{
    if (file_count == 0)
    {
        // serialise all.  That is, call this function again, but with 
        // arguments for all files
        SerialiseBlockToMappedFile(block, 16, 
            sf_normals, sf_normals_r, sf_atvinv, sf_design, sf_meas_minus_comp,
            sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
            sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
            sf_rigorous_vars, sf_prec_adj_msrs, sf_corrections);
        return;
    }
 
    va_list vlist;
    va_start(vlist, file_count);
    
    void* addr;
 
    for (UINT16 file(0); file<file_count; ++file)
    {
        switch (va_arg(vlist, int))
        {
        case sf_normals:
            break;
        case sf_normals_r:
            addr = normalsR_map_.GetBlockRegionAddr(block);
            v_normalsR_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_atvinv:
            break;
        case sf_design:
            break;
        case sf_meas_minus_comp:
            addr = measMinusComp_map_.GetBlockRegionAddr(block);
            v_measMinusComp_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_estimated_stns:
            addr = estimatedStations_map_.GetBlockRegionAddr(block);
            v_estimatedStations_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_original_stns:
            addr = originalStations_map_.GetBlockRegionAddr(block);
            v_originalStations_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_rigorous_stns:
            addr = rigorousStations_map_.GetBlockRegionAddr(block);
            v_rigorousStations_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_junction_vars:
            addr = junctionVariances_map_.GetBlockRegionAddr(block);
            v_junctionVariances_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_junction_vars_f:
            addr = junctionVariancesFwd_map_.GetBlockRegionAddr(block);
            v_junctionVariancesFwd_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_junction_ests_f:
            addr = junctionEstimatesFwd_map_.GetBlockRegionAddr(block);
            v_junctionEstimatesFwd_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_junction_ests_r:
            addr = junctionEstimatesRev_map_.GetBlockRegionAddr(block);
            v_junctionEstimatesRev_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_rigorous_vars:
            addr = rigorousVariances_map_.GetBlockRegionAddr(block);
            v_rigorousVariances_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_prec_adj_msrs:
            addr = precAdjMsrs_map_.GetBlockRegionAddr(block);
            v_precAdjMsrsFull_.at(block).WriteMappedFileRegion(addr);
            break;
        case sf_corrections:
            addr = corrections_map_.GetBlockRegionAddr(block);
            v_corrections_.at(block).WriteMappedFileRegion(addr);
            break;
        }
    }
    va_end(vlist);
}

References corrections_map_, estimatedStations_map_, junctionEstimatesFwd_map_, junctionEstimatesRev_map_, junctionVariances_map_, junctionVariancesFwd_map_, measMinusComp_map_, normalsR_map_, originalStations_map_, precAdjMsrs_map_, rigorousStations_map_, rigorousVariances_map_, SerialiseBlockToMappedFile(), sf_atvinv, sf_corrections, sf_design, sf_estimated_stns, sf_junction_ests_f, sf_junction_ests_r, sf_junction_vars, sf_junction_vars_f, sf_meas_minus_comp, sf_normals, sf_normals_r, sf_original_stns, sf_prec_adj_msrs, sf_rigorous_stns, sf_rigorous_vars, v_corrections_, v_estimatedStations_, v_junctionEstimatesFwd_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesFwd_, v_measMinusComp_, v_normalsR_, v_originalStations_, v_precAdjMsrsFull_, v_rigorousStations_, and v_rigorousVariances_.

Referenced by OffloadBlockToMappedFile(), PrintAdjStationsUniqueList(), PrintAdjustedNetworkStations(), SerialiseBlockToMappedFile(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeserialiseBlockFromMappedFile()

void dynadjust::networkadjust::dna_adjust::DeserialiseBlockFromMappedFile	(	const UINT32 &	block,
		const int	count = 0,
			... )

private

Definition at line 149 of file dnaadjust-stage.cpp.

{
    if (file_count == 0)
    {
        // deserialise all.  That is, call this function again, but with 
        // arguments for all files
        DeserialiseBlockFromMappedFile(block, 15, 
            sf_normals, sf_normals_r, sf_atvinv, sf_design, sf_meas_minus_comp,
            sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
            sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
            sf_rigorous_vars, sf_prec_adj_msrs, sf_corrections);
        return;
    }
 
    va_list vlist;
    va_start(vlist, file_count);
    
    void* addr;
 
    for (UINT16 file(0); file<file_count; ++file)
    {
        switch (va_arg(vlist, int))
        {
        case sf_normals:
            v_normals_.at(block).allocate();
            break;
        case sf_normals_r:
            addr = normalsR_map_.GetBlockRegionAddr(block);
            v_normalsR_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_atvinv:
            v_AtVinv_.at(block).allocate();
            break;
        case sf_design:
            v_design_.at(block).allocate();
            break;
        case sf_meas_minus_comp:
            addr = measMinusComp_map_.GetBlockRegionAddr(block);
            v_measMinusComp_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_estimated_stns:
            addr = estimatedStations_map_.GetBlockRegionAddr(block);
            v_estimatedStations_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_original_stns:
            addr = originalStations_map_.GetBlockRegionAddr(block);
            v_originalStations_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_rigorous_stns:
            addr = rigorousStations_map_.GetBlockRegionAddr(block);
            v_rigorousStations_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_junction_vars:
            addr = junctionVariances_map_.GetBlockRegionAddr(block);
            v_junctionVariances_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_junction_vars_f:
            addr = junctionVariancesFwd_map_.GetBlockRegionAddr(block);
            v_junctionVariancesFwd_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_junction_ests_f:
            addr = junctionEstimatesFwd_map_.GetBlockRegionAddr(block);
            v_junctionEstimatesFwd_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_junction_ests_r:
            addr = junctionEstimatesRev_map_.GetBlockRegionAddr(block);
            v_junctionEstimatesRev_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_rigorous_vars:
            addr = rigorousVariances_map_.GetBlockRegionAddr(block);
            v_rigorousVariances_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_prec_adj_msrs:
            addr = precAdjMsrs_map_.GetBlockRegionAddr(block);
            v_precAdjMsrsFull_.at(block).ReadMappedFileRegion(addr);
            break;
        case sf_corrections:
            addr = corrections_map_.GetBlockRegionAddr(block);
            v_corrections_.at(block).ReadMappedFileRegion(addr);
 
            if (v_blockMeta_.at(block)._blockLast)
                v_correctionsR_.at(block).allocate();
 
            break;
        }
    }
    va_end(vlist);
}

References corrections_map_, DeserialiseBlockFromMappedFile(), estimatedStations_map_, junctionEstimatesFwd_map_, junctionEstimatesRev_map_, junctionVariances_map_, junctionVariancesFwd_map_, measMinusComp_map_, normalsR_map_, originalStations_map_, precAdjMsrs_map_, rigorousStations_map_, rigorousVariances_map_, sf_atvinv, sf_corrections, sf_design, sf_estimated_stns, sf_junction_ests_f, sf_junction_ests_r, sf_junction_vars, sf_junction_vars_f, sf_meas_minus_comp, sf_normals, sf_normals_r, sf_original_stns, sf_prec_adj_msrs, sf_rigorous_stns, sf_rigorous_vars, v_AtVinv_, v_blockMeta_, v_corrections_, v_correctionsR_, v_design_, v_estimatedStations_, v_junctionEstimatesFwd_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesFwd_, v_measMinusComp_, v_normals_, v_normalsR_, v_originalStations_, v_precAdjMsrsFull_, v_rigorousStations_, and v_rigorousVariances_.

Referenced by AdjustPhasedForward(), AdjustPhasedReverse(), CarryForwardJunctions(), CarryReverseJunctions(), ComputeAdjustedMsrPrecisions(), ComputeandPrintAdjMsrOnIteration(), ComputeChiSquareNetwork(), DeSerialiseAdjustedVarianceMatrices(), DeserialiseBlockFromMappedFile(), OutputLargestCorrection(), PrintAdjGNSSAlternateUnits(), PrintAdjStationsUniqueList(), PrintAdjustedNetworkStations(), PrintCorStationsUniqueList(), PrintEstimatedStationCoordinatestoDNAXML_Y(), PrintEstimatedStationCoordinatestoSNX(), PrintNetworkStationCorrections(), PrintPositionalUncertainty(), PrintPosUncertaintiesUniqueList(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UnloadBlock()

void dynadjust::networkadjust::dna_adjust::UnloadBlock	(	const UINT32 &	block,
		const int	file_count = 0,
			... )

private

Definition at line 895 of file dnaadjust-stage.cpp.

{
    if (file_count == 0)
    {
        // deserialise all
        UnloadBlock(block, 16, 
            sf_normals, sf_normals_r, sf_atvinv, sf_design, sf_meas_minus_comp,
            sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
            sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
            sf_rigorous_vars, sf_prec_adj_msrs, sf_corrections);
        return;
    }
 
    va_list vlist;
    va_start(vlist, file_count);
 
    // Unload block matrix data from memory
    for (UINT16 file(0); file<file_count; ++file)
    {
        switch (va_arg(vlist, int))
        {
        case sf_normals:
            v_normals_.at(block).~matrix_2d();
            break;
        case sf_normals_r:
            v_normalsR_.at(block).~matrix_2d();
            break;
        case sf_atvinv:
            v_AtVinv_.at(block).~matrix_2d();
            break;
        case sf_design:
            v_design_.at(block).~matrix_2d();
            break;
        case sf_meas_minus_comp:
            v_measMinusComp_.at(block).~matrix_2d();
            break;
        case sf_estimated_stns:
            v_estimatedStations_.at(block).~matrix_2d();
            break;
        case sf_original_stns:
            v_originalStations_.at(block).~matrix_2d();
            break;
        case sf_rigorous_stns:
            v_rigorousStations_.at(block).~matrix_2d();
            break;
        case sf_junction_vars:
            v_junctionVariances_.at(block).~matrix_2d();
            break;
        case sf_junction_vars_f:
            v_junctionVariancesFwd_.at(block).~matrix_2d();
            break;
        case sf_junction_ests_f:
            v_junctionEstimatesFwd_.at(block).~matrix_2d();
            break;
        case sf_junction_ests_r:
            v_junctionEstimatesRev_.at(block).~matrix_2d();
            break;
        case sf_rigorous_vars:
            v_rigorousVariances_.at(block).~matrix_2d();
            break;
        case sf_prec_adj_msrs:
            v_precAdjMsrsFull_.at(block).~matrix_2d();
            break;
        case sf_corrections:
            v_corrections_.at(block).~matrix_2d();
 
            if (v_blockMeta_.at(block)._blockLast)
                v_correctionsR_.at(block).~matrix_2d();
            break;
        }
    }
    va_end(vlist);
}

References sf_atvinv, sf_corrections, sf_design, sf_estimated_stns, sf_junction_ests_f, sf_junction_ests_r, sf_junction_vars, sf_junction_vars_f, sf_meas_minus_comp, sf_normals, sf_normals_r, sf_original_stns, sf_prec_adj_msrs, sf_rigorous_stns, sf_rigorous_vars, UnloadBlock(), v_AtVinv_, v_blockMeta_, v_corrections_, v_correctionsR_, v_design_, v_estimatedStations_, v_junctionEstimatesFwd_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesFwd_, v_measMinusComp_, v_normals_, v_normalsR_, v_originalStations_, v_precAdjMsrsFull_, v_rigorousStations_, and v_rigorousVariances_.

Referenced by ComputeAdjustedMsrPrecisions(), ComputeandPrintAdjMsrOnIteration(), ComputeChiSquareNetwork(), OffloadBlockToDisk(), OffloadBlockToMappedFile(), OutputLargestCorrection(), PrintAdjGNSSAlternateUnits(), PrintAdjStationsUniqueList(), PrintAdjustedNetworkStations(), PrintCorStationsUniqueList(), PrintEstimatedStationCoordinatestoDNAXML_Y(), PrintEstimatedStationCoordinatestoSNX(), PrintNetworkStationCorrections(), PrintPositionalUncertainty(), PrintPosUncertaintiesUniqueList(), UnloadBlock(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PurgeMatricesFromDisk()

void dynadjust::networkadjust::dna_adjust::PurgeMatricesFromDisk ( )

private

Definition at line 3819 of file dnaadjust.cpp.

{
    // remove all the files
    for_each(
        v_stageFileStreams_.begin(), 
        v_stageFileStreams_.end(), 
        [](std::string str){            // use lambda expression
            
            // remove mapping
            boost::interprocess::file_mapping::remove(str.c_str());
            // If the file still exists, remove it!
            if (boost::filesystem::exists(str))
            boost::interprocess::file_mapping::remove(str.c_str());
        }
    );  
}

References v_stageFileStreams_.

◆ AddMsrtoMeasMinusComp()

void dynadjust::networkadjust::dna_adjust::AddMsrtoMeasMinusComp	(	pit_vmsr_t	_it_msr,
		const UINT32 &	design_row,
		const double	comp_msr,
		matrix_2d *	measMinusComp,
		bool	printBlock = true )

private

Definition at line 5724 of file dnaadjust.cpp.

{
    double mmc((*_it_msr)->term1 - comp_msr);
    
    switch ((*_it_msr)->measType)
    {
    case 'A':
    case 'B':
    case 'D':
    case 'K':
        // check if residual is close to +/- 360 (make close to 0)
        if (mmc < -5.5)
            mmc += TWO_PI;
        else if (mmc > 5.5)
            mmc -= TWO_PI;
    }
 
    // measured - computed
    measMinusComp->put(design_row, 0, mmc);      
 
    if (projectSettings_.g.verbose > 5)
    {
        if (printBlock)
            debug_file << bstBinaryRecords_.at((*_it_msr)->station1).stationName <<
                " - " << bstBinaryRecords_.at((*_it_msr)->station2).stationName;
        debug_file << std::endl;
        debug_file << "d" << (*_it_msr)->measType << " " << std::fixed << std::setprecision(16) << std::setw(26) << 
            mmc <<
            " = " << std::setw(26) << (*_it_msr)->term1 << 
            " - " << std::setw(26) << comp_msr << "  ";
    }
}

References bstBinaryRecords_, debug_file, projectSettings_, dynadjust::math::matrix_2d::put(), and TWO_PI().

Referenced by UpdateDesignMeasMatrices_GX(), UpdateDesignNormalMeasMatrices_A(), UpdateDesignNormalMeasMatrices_BK(), UpdateDesignNormalMeasMatrices_CEM(), UpdateDesignNormalMeasMatrices_HR(), UpdateDesignNormalMeasMatrices_IP(), UpdateDesignNormalMeasMatrices_JQ(), UpdateDesignNormalMeasMatrices_L(), UpdateDesignNormalMeasMatrices_S(), UpdateDesignNormalMeasMatrices_V(), UpdateDesignNormalMeasMatrices_Y(), and UpdateDesignNormalMeasMatrices_Z().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddMsrtoNormalsVar()

void dynadjust::networkadjust::dna_adjust::AddMsrtoNormalsVar	(	const UINT32 &	design_row,
		const UINT32 &	stn,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv )

private

Definition at line 1599 of file dnaadjust.cpp.

{
    // Add weighted measurement contributions to normal matrix
    for (UINT32 row, col(0); col<3; ++col)
    {
        for (row=0; row<3; ++row)
        {
            normals->elementadd(stn+row, stn+col,
                AtVinv->get(stn+row, design_row) * design->get(design_row, stn+col));
        }
    }
}

References dynadjust::math::matrix_2d::elementadd(), and dynadjust::math::matrix_2d::get().

Referenced by UpdateNormals_A(), UpdateNormals_BCEKLMSVZ(), and UpdateNormals_HIJPQR().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddMsrtoNormalsCoVar2()

void dynadjust::networkadjust::dna_adjust::AddMsrtoNormalsCoVar2	(	const UINT32 &	design_row,
		const UINT32 &	stn1,
		const UINT32 &	stn2,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv )

private

Definition at line 1614 of file dnaadjust.cpp.

{
    // Add covariance terms (station 1 and station 2) to normal matrix
    for (UINT32 row, col(0); col<3; ++col)
    {
        for (row=0; row<3; ++row)
        {
            // 1-2
            normals->elementadd(stn1+row, stn2+col,
                AtVinv->get(stn1+row, design_row) * design->get(design_row, stn2+col));
 
            normals->elementadd(stn2+row, stn1+col,
                AtVinv->get(stn2+row, design_row) * design->get(design_row, stn1+col));
        }
    }
}

References dynadjust::math::matrix_2d::elementadd(), and dynadjust::math::matrix_2d::get().

Referenced by UpdateNormals_BCEKLMSVZ().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddMsrtoNormalsCoVar3()

void dynadjust::networkadjust::dna_adjust::AddMsrtoNormalsCoVar3	(	const UINT32 &	design_row,
		const UINT32 &	stn1,
		const UINT32 &	stn2,
		const UINT32 &	stn3,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv )

private

Definition at line 1632 of file dnaadjust.cpp.

{
    // Add covariance terms (station 1, station 2, station 3) to normal matrix
    for (UINT32 row, col(0); col<3; ++col)
    {
        for (row=0; row<3; ++row)
        {
            // 1-2
            normals->elementadd(stn1+row, stn2+col,
                AtVinv->get(stn1+row, design_row) * design->get(design_row, stn2+col));
 
            normals->elementadd(stn2+row, stn1+col,
                AtVinv->get(stn2+row, design_row) * design->get(design_row, stn1+col));
 
            // 1-3
            normals->elementadd(stn1+row, stn3+col,
                AtVinv->get(stn1+row, design_row) * design->get(design_row, stn3+col));
 
            normals->elementadd(stn3+row, stn1+col,
                AtVinv->get(stn3+row, design_row) * design->get(design_row, stn1+col));
            
            // 2-3
            normals->elementadd(stn2+row, stn3+col,
                AtVinv->get(stn2+row, design_row) * design->get(design_row, stn3+col));
 
            normals->elementadd(stn3+row, stn2+col,
                AtVinv->get(stn3+row, design_row) * design->get(design_row, stn2+col));
        }
    }
}

References dynadjust::math::matrix_2d::elementadd(), and dynadjust::math::matrix_2d::get().

Referenced by UpdateNormals_A().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddMsrtoDesign()

void dynadjust::networkadjust::dna_adjust::AddMsrtoDesign	(	const UINT32 &	design_row,
		const UINT32 &	stn,
		const double &	dmdx,
		const double &	dmdy,
		const double &	dmdz,
		matrix_2d *	design )

inlineprivate

Definition at line 5693 of file dnaadjust.cpp.

{
        // design matrix elements for dA/dX1, dA/dY1, dA/dZ1 for 1 station
    AddElementtoDesign(design_row, stn, dmdx, design);
    AddElementtoDesign(design_row, stn+1, dmdy, design);
    AddElementtoDesign(design_row, stn+2, dmdz, design);
}

References AddElementtoDesign().

Referenced by AddMsrtoDesign_BCEKMSVZ(), and AddMsrtoDesign_L().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddMsrtoDesign_L()

void dynadjust::networkadjust::dna_adjust::AddMsrtoDesign_L	(	const UINT32 &	design_row,
		const UINT32 &	stn1,
		const UINT32 &	stn2,
		const double	dmdx1,
		const double	dmdy1,
		const double	dmdz1,
		const double	dmdx2,
		const double	dmdy2,
		const double	dmdz2,
		matrix_2d *	design )

inlineprivate

Definition at line 5703 of file dnaadjust.cpp.

{
    // design matrix dA/dX1, dA/dY1, dA/dZ1
    AddMsrtoDesign(design_row, stn1, dmdx1, dmdy1, dmdz1, design);    
    // design matrix dA/dX2, dA/dY2, dA/dZ2
    AddMsrtoDesign(design_row, stn2, dmdx2, dmdy2, dmdz2, design);
}

References AddMsrtoDesign().

Referenced by UpdateDesignNormalMeasMatrices_L().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddMsrtoDesign_BCEKMSVZ()

void dynadjust::networkadjust::dna_adjust::AddMsrtoDesign_BCEKMSVZ	(	const UINT32 &	design_row,
		const UINT32 &	stn1,
		const UINT32 &	stn2,
		const double	dmdx,
		const double	dmdy,
		const double	dmdz,
		matrix_2d *	design )

inlineprivate

Definition at line 5714 of file dnaadjust.cpp.

{
    // design matrix dA/dX1, dA/dY1, dA/dZ1
    AddMsrtoDesign(design_row, stn1, dmdx, dmdy, dmdz, design);   
    // design matrix dA/dX2, dA/dY2, dA/dZ2
    AddMsrtoDesign(design_row, stn2, -dmdx, -dmdy, -dmdz, design);
}

References AddMsrtoDesign().

Referenced by UpdateDesignNormalMeasMatrices_BK(), UpdateDesignNormalMeasMatrices_CEM(), UpdateDesignNormalMeasMatrices_S(), UpdateDesignNormalMeasMatrices_V(), and UpdateDesignNormalMeasMatrices_Z().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddElementtoDesign()

void dynadjust::networkadjust::dna_adjust::AddElementtoDesign	(	const UINT32 &	row,
		const UINT32 &	col,
		const double	value,
		matrix_2d *	design )

inlineprivate

Definition at line 5687 of file dnaadjust.cpp.

{
    design->put(row, col, value);
}

References dynadjust::math::matrix_2d::put().

Referenced by AddMsrtoDesign(), UpdateDesignMeasMatrices_GX(), UpdateDesignNormalMeasMatrices_A(), UpdateDesignNormalMeasMatrices_HR(), UpdateDesignNormalMeasMatrices_IP(), UpdateDesignNormalMeasMatrices_JQ(), and UpdateDesignNormalMeasMatrices_Y().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		bool	buildnewMatrices,
		const UINT32 &	block,
		bool	MT_ReverseOrCombine )

private

Definition at line 4871 of file dnaadjust.cpp.

{
    std::stringstream ss;
 
    matrix_2d* estimatedStations(&v_estimatedStations_.at(block));
    matrix_2d* design(&v_design_.at(block));
    matrix_2d* AtVinv(&v_AtVinv_.at(block));
    matrix_2d* measMinusComp(&v_measMinusComp_.at(block));
    matrix_2d* normals(&v_normals_.at(block));
 
    if (MT_ReverseOrCombine)
    {
        estimatedStations = &v_estimatedStationsR_.at(block);
        design = &v_designR_.at(block);
        AtVinv = &v_AtVinvR_.at(block);
        measMinusComp = &v_measMinusCompR_.at(block);
    }   
 
    switch ((*_it_msr)->measType)
    {
    case 'A':   // Horizontal angle
        UpdateDesignNormalMeasMatrices_A(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    case 'B':   // Geodetic azimuth
    case 'K':   // Astronomic azimuth
        // Note: UpdateDesignNormalMeasMatrices_BK reduces K measurements to the geodetic reference frame, 
        // after which UpdateDesignNormalMeasMatrices_BK treats K measurements as B measurements upon forming
        // design matrix elements.
        UpdateDesignNormalMeasMatrices_BK(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);   
        break;
    case 'C':   // Chord dist
        UpdateDesignNormalMeasMatrices_C(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    case 'D':   // Direction set    
        UpdateDesignNormalMeasMatrices_D(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    case 'E':   // Ellipsoid arc
        UpdateDesignNormalMeasMatrices_E(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    case 'G':   // GPS Baseline
        UpdateDesignNormalMeasMatrices_G(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    case 'H':   // Orthometric height
        // Note: UpdateDesignNormalMeasMatrices_H reduces term1 to ellipsoid height, after which
        // UpdateDesignNormalMeasMatrices_HR is used to form design elements.
        UpdateDesignNormalMeasMatrices_H(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    case 'I':   // Astronomic latitude
        // Note: UpdateDesignNormalMeasMatrices_I reduces term1 to geodetic latitude, after which
        // UpdateDesignNormalMeasMatrices_IP is used to form design elements.
        UpdateDesignNormalMeasMatrices_I(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    case 'J':   // Astronomic longitude
        // Note: UpdateDesignNormalMeasMatrices_J reduces term1 to geodetic longitude, after which
        // UpdateDesignNormalMeasMatrices_JQ is used to form design elements.
        UpdateDesignNormalMeasMatrices_J(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;      
    case 'L':   // Level difference
        UpdateDesignNormalMeasMatrices_L(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;      
    case 'M':   // MSL arc
        UpdateDesignNormalMeasMatrices_M(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;      
    case 'P':   // Geodetic latitude
        // Note: UpdateDesignNormalMeasMatrices_P archives the raw measurement, after which
        // UpdateDesignNormalMeasMatrices_IP is used to form design elements.
        UpdateDesignNormalMeasMatrices_P(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;      
    case 'Q':   // Geodetic longitude
        // Note: UpdateDesignNormalMeasMatrices_Q archives the raw measurement, after which
        // UpdateDesignNormalMeasMatrices_JQ is used to form design elements.
        UpdateDesignNormalMeasMatrices_Q(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;      
    case 'R':   // Ellipsoidal height
        // Note: UpdateDesignNormalMeasMatrices_R archives the raw measurement, after which
        // UpdateDesignNormalMeasMatrices_HR is used to form design elements.
        UpdateDesignNormalMeasMatrices_R(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    case 'S':   // Slope distance
        UpdateDesignNormalMeasMatrices_S(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    case 'V':   // Zenith distance
        UpdateDesignNormalMeasMatrices_V(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;      
    case 'X':   // GPS Baseline cluster
        UpdateDesignNormalMeasMatrices_X(_it_msr, design_row, block,
            measMinusComp, estimatedStations, design, AtVinv, buildnewMatrices);
        break;      
    case 'Y':   // GPS Point cluster
        UpdateDesignNormalMeasMatrices_Y(_it_msr, design_row, block,
            measMinusComp, estimatedStations, design, AtVinv, buildnewMatrices);
        break;      
    case 'Z':   // Vertical angle
        UpdateDesignNormalMeasMatrices_Z(_it_msr, design_row, block,
            measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
        break;
    default:
        ss << "UpdateDesignNormalMeasMatrices(): Unknown measurement type - '" <<
            (*_it_msr)->measType << "'." << std::endl;
        SignalExceptionAdjustment(ss.str(), block);
    }
}

Referenced by FillDesignNormalMeasurementsMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_A()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_A	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 5759 of file dnaadjust.cpp.

{
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
    UINT32 stn3(GetBlkMatrixElemStn3(block, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
 
    double direction12, direction13, local_12e, local_12n, local_13e, local_13n;
 
    // compute angle 1 -> 2 -> 3 from estimated coordinates
    double comp_msr(HorizontalAngle(
        estimatedStations->get(stn1, 0),     // X1
        estimatedStations->get(stn1+1, 0),       // Y1
        estimatedStations->get(stn1+2, 0),       // Z1
        estimatedStations->get(stn2, 0),         // X2
        estimatedStations->get(stn2+1, 0),       // Y2
        estimatedStations->get(stn2+2, 0),       // Z2
        estimatedStations->get(stn3, 0),         // X3
        estimatedStations->get(stn3+1, 0),       // Y3
        estimatedStations->get(stn3+2, 0),       // Z3
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        &direction12, &direction13, 
        &local_12e, &local_12n, &local_13e, &local_13n));
    
    // Initialise measurement.  No need to test if no further calculations are 
    // required (as in stage mode), as this is done later (below)
    InitialiseMeasurement(_it_msr, buildnewMatrices);
 
    if (buildnewMatrices)
    {
        // deflections available?
        if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
        {
            it_vstn_t stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
            it_vstn_t stn3_it(bstBinaryRecords_.begin() + (*_it_msr)->station3);
            // Angles (observed or derived from directions) must be corrected for deflection 
            // of the vertical via "Laplace correction".  This correction requires zenith 
            // distance (zenith12, zenith13) and geodetic azimuth (direction12, direction13), 
            // both of which must be computed from coordinates.
            // Compute zenith distance 1 -> 2
            double zenith12(ZenithDistance<double>(
                estimatedStations->get(stn1, 0),         // X1
                estimatedStations->get(stn1+1, 0),           // Y1
                estimatedStations->get(stn1+2, 0),           // Z1
                estimatedStations->get(stn2, 0),             // X2
                estimatedStations->get(stn2+1, 0),           // Y2
                estimatedStations->get(stn2+2, 0),           // Z2
                stn1_it->currentLatitude,
                stn1_it->currentLongitude,
                stn2_it->currentLatitude,
                stn2_it->currentLongitude,
                (*_it_msr)->term3,                          // instrument height
                (*_it_msr)->term4));                        // target height
            // Compute zenith distance 1 -> 3
            double zenith13(ZenithDistance<double>(
                estimatedStations->get(stn1, 0),         // X1
                estimatedStations->get(stn1+1, 0),           // Y1
                estimatedStations->get(stn1+2, 0),           // Z1
                estimatedStations->get(stn3, 0),             // X2
                estimatedStations->get(stn3+1, 0),           // Y2
                estimatedStations->get(stn3+2, 0),           // Z2
                stn1_it->currentLatitude,
                stn1_it->currentLongitude,
                stn3_it->currentLatitude,
                stn3_it->currentLongitude,
                (*_it_msr)->term3,                          // instrument height
                (*_it_msr)->term4));                        // target height
 
            // Laplace correction 1 -> 2 -> 3
            (*_it_msr)->preAdjCorr = HzAngleDeflectionCorrection<double>(        
                direction12,                                // geodetic azimuth 1 -> 2
                zenith12,                                   // zenith distance 1 -> 2
                direction13,                                // geodetic azimuth 1 -> 3
                zenith13,                                   // zenith distance 1 -> 3
                stn1_it->verticalDef,                       // deflection in prime vertical
                stn1_it->meridianDef);                      // deflection in prime meridian
 
            (*_it_msr)->term1 -= (*_it_msr)->preAdjCorr;    // apply deflection correction
        }
        else
            (*_it_msr)->preAdjCorr = 0.0;
 
        if (projectSettings_.a.stage)
            return;
    }
 
    // Update measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, comp_msr, measMinusComp);
 
    double cos_lat(cos(stn1_it->currentLatitude));
    double sin_lat(sin(stn1_it->currentLatitude));
    double cos_long(cos(stn1_it->currentLongitude));
    double sin_long(sin(stn1_it->currentLongitude));
    double sinlat_coslong(sin_lat*cos_long);
    double sinlat_sinlong(sin_lat*sin_long);
    double cos2_dir12_div_n122(cos(direction12) * cos(direction12) / (local_12n * local_12n));
    double cos2_dir13_div_n132(cos(direction13) * cos(direction13) / (local_13n * local_13n));
 
    // compute partial derivatives for normals
    // design matrix dA/dX1, dA/dY1, dA/dZ1
    AddElementtoDesign(design_row, stn1, 
        cos2_dir13_div_n132 * (local_13n * sin_long - local_13e * sinlat_coslong) - 
        cos2_dir12_div_n122 * (local_12n * sin_long - local_12e * sinlat_coslong),
        design);                                                                        // X1
    AddElementtoDesign(design_row, stn1+1,  
        cos2_dir13_div_n132 * (-local_13n * cos_long - local_13e * sinlat_sinlong) - 
        cos2_dir12_div_n122 * (-local_12n * cos_long - local_12e * sinlat_sinlong),
        design);                                                                        // Y1
    AddElementtoDesign(design_row, stn1+2, 
        cos2_dir13_div_n132 * local_13e * cos_lat - 
        cos2_dir12_div_n122 * local_12e * cos_lat, design);                             // Z1
 
    // design matrix dA/dX2, dA/dY2, dA/dZ2
    AddElementtoDesign(design_row, stn2, 
        cos2_dir12_div_n122 * (local_12n * sin_long - local_12e * sinlat_coslong),
        design);                                                                        // X2
    AddElementtoDesign(design_row, stn2+1, 
        cos2_dir12_div_n122 * (-local_12n * cos_long - local_12e * sinlat_sinlong),
        design);                                                                        // Y2
    AddElementtoDesign(design_row, stn2+2, 
        cos2_dir12_div_n122 * local_12e * cos_lat, design);                             // Z2
 
    // design matrix dA/dX3, dA/dY3, dA/dZ3
    AddElementtoDesign(design_row, stn3, 
        -cos2_dir13_div_n132 * (local_13n * sin_long - local_13e * sinlat_coslong),
        design);                                                                        // X3
    AddElementtoDesign(design_row, stn3+1, 
        -cos2_dir13_div_n132 * (-local_13n * cos_long - local_13e * sinlat_sinlong),
        design);                                                                        // Y3
    AddElementtoDesign(design_row, stn3+2, 
        -cos2_dir13_div_n132 * local_13e * cos_lat, design);                            // Z3
    
    switch ((*_it_msr)->measType)
    {
    case 'D':
        // return to UpdateDesignNormalMeasMatrices_D(...)
        return;
    }
 
    UpdateAtVinv(_it_msr, stn1, stn2, stn3, design_row, design, AtVinv, buildnewMatrices);
 
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_A(stn1, stn2, stn3, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddElementtoDesign(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, E4_SEC_DEFLECTION(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), GetBlkMatrixElemStn3(), HorizontalAngle(), HzAngleDeflectionCorrection(), InitialiseMeasurement(), projectSettings_, UpdateAtVinv(), UpdateNormals_A(), and ZenithDistance().

Referenced by UpdateDesignNormalMeasMatrices(), and UpdateDesignNormalMeasMatrices_D().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_BK()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_BK	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 5918 of file dnaadjust.cpp.

{
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    double local_12e, local_12n;
 
    // compute bearing from estimated coordinates
    double comp_msr(Direction(
        estimatedStations->get(stn1, 0),     // X1
        estimatedStations->get(stn1+1, 0),       // Y1
        estimatedStations->get(stn1+2, 0),       // Z1
        estimatedStations->get(stn2, 0),         // X2
        estimatedStations->get(stn2+1, 0),       // Y2
        estimatedStations->get(stn2+2, 0),       // Z2
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        &local_12e, &local_12n));
    
    // Initialise measurement.  No need to test if no further calculations are 
    // required (as in stage mode), as this is done later (below)
    InitialiseMeasurement(_it_msr, buildnewMatrices);
    
    if (buildnewMatrices)
    {
        // deflections available?
        if ((*_it_msr)->measType == 'K' &&                      // Astro
            (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || // deflections available?
             fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION))  
        {
            // Astronomic azimuths must be corrected for deflection of the vertical via
            // "Laplace correction".  This correction requires zenith distance and geodetic 
            // azimuth (comp_msr), both of which must be computed from coordinates.
        
            // Compute zenith distance
            double zenith(ZenithDistance<double>(
                estimatedStations->get(stn1, 0),                 // X1
                estimatedStations->get(stn1+1, 0),                   // Y1
                estimatedStations->get(stn1+2, 0),                   // Z1
                estimatedStations->get(stn2, 0),                     // X2
                estimatedStations->get(stn2+1, 0),                   // Y2
                estimatedStations->get(stn2+2, 0),                   // Z2
                stn1_it->currentLatitude,
                stn1_it->currentLongitude,
                stn2_it->currentLatitude,
                stn2_it->currentLongitude,
                (*_it_msr)->term3,                                  // instrument height
                (*_it_msr)->term4));                                // target height
 
            (*_it_msr)->preAdjCorr = LaplaceCorrection<double>(        // Laplace correction
                comp_msr,                                           // geodetic azimuth
                zenith,                                             // zenith distance
                stn1_it->verticalDef,                               // deflection in prime vertical
                stn1_it->meridianDef,                               // deflection in prime meridian
                stn1_it->currentLatitude);
 
            // scale4 must be used since term3 and term4 are station and target heights respectively
            (*_it_msr)->term1 -= (*_it_msr)->preAdjCorr;            // apply deflection correction
        }
        else
            (*_it_msr)->preAdjCorr = 0.0;
 
        if (projectSettings_.a.stage)
            return;
    }
 
    // Update measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, comp_msr, measMinusComp);
    // compute partial derivatives for normals
    double cos_lat(cos(stn1_it->currentLatitude));
    double sin_lat(sin(stn1_it->currentLatitude));
    double cos_long(cos(stn1_it->currentLongitude));
    double sin_long(sin(stn1_it->currentLongitude));
    double sinlat_coslong(sin_lat*cos_long);
    double sinlat_sinlong(sin_lat*sin_long);
    double cos2_dir12_div_n122(cos(comp_msr) * cos(comp_msr) / (local_12n * local_12n));
    
    // Add partial derivatives dA/dX1, dA/dY1, dA/dZ1 to design matrix
    AddMsrtoDesign_BCEKMSVZ(design_row, stn1, stn2,
        cos2_dir12_div_n122 * (local_12n * sin_long - local_12e * sinlat_coslong),
        cos2_dir12_div_n122 * (-local_12n * cos_long - local_12e * sinlat_sinlong),
        cos2_dir12_div_n122 * local_12e * cos_lat,
        design);
    
    // Update AtVinv based on new design matrix elements
    UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddMsrtoDesign_BCEKMSVZ(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, Direction(), E4_SEC_DEFLECTION(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), InitialiseMeasurement(), LaplaceCorrection(), projectSettings_, UpdateAtVinv(), UpdateNormals_BCEKLMSVZ(), and ZenithDistance().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_C()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_C	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6022 of file dnaadjust.cpp.

{
    // Initialise measurement and test if no further calculations are 
    // required (as in stage mode)
    if (InitialiseMeasurement(_it_msr, buildnewMatrices))
        return;
 
    // As a C measurement is a direct vector between two points in the cartesian frame,
    // there will be no pre adjustment correction
    (*_it_msr)->preAdjCorr = 0.;
 
    // Now call UpdateDesignNormalMeasMatrices_CEM
    UpdateDesignNormalMeasMatrices_CEM(_it_msr, design_row, block,
        measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
}

References InitialiseMeasurement(), and UpdateDesignNormalMeasMatrices_CEM().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_CEM()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_CEM	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6041 of file dnaadjust.cpp.

{
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    double dX, dY, dZ;
 
    // calculated distance
    double comp_msr(EllipsoidChordDistance<double>(
        estimatedStations->get(stn1, 0),
        estimatedStations->get(stn1+1, 0),
        estimatedStations->get(stn1+2, 0),
        estimatedStations->get(stn2, 0),
        estimatedStations->get(stn2+1, 0),
        estimatedStations->get(stn2+2, 0),
        stn1_it->currentLatitude,
        stn2_it->currentLatitude,
        stn1_it->currentHeight,
        stn2_it->currentHeight,
        &dX, &dY, &dZ, 
        datum_.GetEllipsoidRef()));
    
    // Update measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, comp_msr, measMinusComp);
 
    // Add partial derivatives dA/dX1, dA/dY1, dA/dZ1 to design matrix
    AddMsrtoDesign_BCEKMSVZ(design_row, stn1, stn2,
        -dX/comp_msr, -dY/comp_msr, -dZ/comp_msr,
        design);
 
    // Update AtVinv based on new design matrix elements
    UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddMsrtoDesign_BCEKMSVZ(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, datum_, EllipsoidChordDistance(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), UpdateAtVinv(), and UpdateNormals_BCEKLMSVZ().

Referenced by UpdateDesignNormalMeasMatrices_C(), UpdateDesignNormalMeasMatrices_E(), and UpdateDesignNormalMeasMatrices_M().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_D()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_D	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6087 of file dnaadjust.cpp.

{
    it_vmsr_t _it_msr_first(*_it_msr);
    UINT32 design_row_begin(design_row);
 
    UINT32 a, angle_count((*_it_msr)->vectorCount2 - 1);      // number of directions excluding the RO
    UINT32 skip(0), ignored((*_it_msr)->vectorCount1 - (*_it_msr)->vectorCount2);
    
    vmsr_t angleRec;
    angleRec.push_back(*(*_it_msr));
    it_vmsr_t it_angle(angleRec.begin());
 
    double previousDirection((*_it_msr)->term1);
 
    (*_it_msr)++;
 
    // set derived angle, variance and covariance to the binary records
    // term1 = measured direction
    // term2 = variance (direction)
    // term3 = instrument height (not used)
    // term4 = target height (not used)
    // scale1 = derived angle corrected for deflection of the vertical
    // scale2 = variance (angle)
    // scale3 = covariance (angle) - for the context of vmsr_t angleRec only, so as to 
    //          properly form the normals from covariances formed from directions SDs
    // vectorCount2 = number of non-ignored directions
    // preAdjMeas = original derived angle
    
    if (projectSettings_.g.verbose > 6)
        debug_file << "Reduced angles from raw directions: ";
 
    try
    {
        for (a=0; a<angle_count; ++a)
        {
            // cater for ignored directions
            if ((*_it_msr)->ignore)
            {
                while (skip < ignored)
                {                   
                    skip++;
                    (*_it_msr)++;
                    if (!(*_it_msr)->ignore)
                        break;                      
                }
            }
 
            it_angle->station3 = (*_it_msr)->station2;
            
            if (buildnewMatrices)
            {
                // Was this measurement reduced from previous
                // adjustment, which was serialised to disk?
                if (bms_meta_.reduced)
                    // derived angle uncorrected for deflection of vertical
                    it_angle->preAdjMeas = (*_it_msr)->preAdjMeas;
                else
                {
                    // Derive the angle from two directions
                    it_angle->term1 = (*_it_msr)->term1 - previousDirection;
                    if (it_angle->term1 < 0)
                        it_angle->term1 += TWO_PI;
                    if (it_angle->term1 > TWO_PI)
                        it_angle->term1 -= TWO_PI;
 
                    if (projectSettings_.g.verbose > 6)
                    {
                        debug_file << std::endl << "angle " <<
                            StringFromT(RadtoDms(it_angle->term1), 6) << " = " <<
                            StringFromT(RadtoDms((*_it_msr)->term1), 6) << " - " <<
                            StringFromT(RadtoDms(previousDirection), 6) << std::endl;
                    }
                }
            }
            else
                // derived angle corrected for deflection of vertical
                it_angle->term1 = (*_it_msr)->scale1;
            
            // normals not needed
            UpdateDesignNormalMeasMatrices_A(&it_angle, design_row, block,
                measMinusComp, estimatedStations, 0, design, AtVinv, buildnewMatrices);
 
            if (buildnewMatrices)
            {
                // Update derived angle, corrected for deflection of vertical
                (*_it_msr)->scale1 = it_angle->term1;
                // Update derived angle, uncorrected for deflection of vertical
                (*_it_msr)->preAdjMeas = it_angle->preAdjMeas;
                // Update correction for deflection of the vertical
                (*_it_msr)->preAdjCorr = it_angle->preAdjCorr;
            }
 
            if (a + 1 == angle_count)
            {
                // check for any ignored directions
                if (_it_msr_first->vectorCount1 != _it_msr_first->vectorCount2)
                    (*_it_msr) = _it_msr_first + _it_msr_first->vectorCount1;
                break;
            }
 
            if (buildnewMatrices)
                previousDirection = (*_it_msr)->term1;
 
            // prepare for next angle
            angleRec.push_back(*(*_it_msr));
            it_angle = angleRec.end() - 1;
 
            (*_it_msr)++;   
            design_row++;
        }
    }
    catch (...) {
 
        // Print error message to adj file and throw exception
        std::stringstream ss;
        ss << "UpdateDesignNormalMeasMatrices_D(): An error was encountered whilst" << std::endl <<
            "  updating the normal matrices" << std::endl;
        SignalExceptionAdjustment(ss.str(), block);
    }
 
    // Load apriori variance matrix, and assign to binary measurement
    matrix_2d var_dirn(angle_count, angle_count);
    LoadVarianceMatrix_D(_it_msr_first, &var_dirn, buildnewMatrices);
 
    if (buildnewMatrices && projectSettings_.a.stage)
        return;
 
    UINT32 stn1, stn2, stn3;
    it_angle = angleRec.begin();
    design_row = design_row_begin;
 
    // clear rows in AtVinv relating to this measurement
    AtVinv->zero(0, design_row, AtVinv->rows(), angle_count);
 
    if (!buildnewMatrices)
        debug_file << "block " << block + 1 << ", design_row " << design_row + 1 << ", directions var" << var_dirn << std::endl;
 
    // Update AtVinv based on new design matrix elements
    for (a=0; a<angle_count; ++a)                                                                 // for each angle
    {
        stn1 = (v_blockStationsMap_.at(block)[it_angle->station1] * 3); 
        stn2 = (v_blockStationsMap_.at(block)[it_angle->station2] * 3);
        stn3 = (v_blockStationsMap_.at(block)[it_angle->station3] * 3);
        
        // Update AtVinv
        UpdateAtVinv_D(stn1, stn2, stn3, a, angle_count, 
            design_row, design_row_begin, 
            &var_dirn, design, AtVinv);
 
        design_row++;
        it_angle++;
    }
 
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_D(block, _it_msr_first, design_row_begin, normals, design, AtVinv);
}

References bms_meta_, debug_file, LoadVarianceMatrix_D(), projectSettings_, RadtoDms(), dynadjust::math::matrix_2d::rows(), SignalExceptionAdjustment(), StringFromT(), TWO_PI(), UpdateAtVinv_D(), UpdateDesignNormalMeasMatrices_A(), UpdateNormals_D(), v_blockStationsMap_, and dynadjust::math::matrix_2d::zero().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_E()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_E	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6247 of file dnaadjust.cpp.

{
    // Initialise measurement and test if no further calculations are 
    // required (as in stage mode)
    if (InitialiseMeasurement(_it_msr, buildnewMatrices))
        return;
 
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    // Note: Each measured Ellipsoid arc is reduced to an ellipsoid chord on first run.
    // Whist it would be more efficient to not reduce this distance on each iteration,
    // the ellipsoid chord is recomputed every time using the original measurement
    // to cater for (potentially) large changes in latitude and longitude, 
    
    // Reduce Ellipsoid arc to Ellipsoid chord
    (*_it_msr)->term1 = EllipsoidArctoEllipsoidChord<double>(
        (*_it_msr)->preAdjMeas,
        estimatedStations->get(stn1, 0), 
        estimatedStations->get(stn1+1, 0),
        estimatedStations->get(stn1+2, 0),
        estimatedStations->get(stn2, 0),
        estimatedStations->get(stn2+1, 0),
        estimatedStations->get(stn2+2, 0),
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        stn2_it->currentLatitude,
        datum_.GetEllipsoidRef());
 
    (*_it_msr)->preAdjCorr = (*_it_msr)->term1 - (*_it_msr)->preAdjMeas;
 
    // Now that the ellipsoid arc has been reduced to a chord, call UpdateDesignNormalMeasMatrices_CEM
    UpdateDesignNormalMeasMatrices_CEM(_it_msr, design_row, block,
        measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
}

References bstBinaryRecords_, datum_, EllipsoidArctoEllipsoidChord(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), InitialiseMeasurement(), and UpdateDesignNormalMeasMatrices_CEM().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignMeasMatrices_GX()

void dynadjust::networkadjust::dna_adjust::UpdateDesignMeasMatrices_GX	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	design,
		const UINT32 &	stn1,
		const UINT32 &	stn2,
		bool	buildnewMatrices )

private

Definition at line 6288 of file dnaadjust.cpp.

{
    // If this method is called via PrepareAdjustment() and the adjustment 
    // mode is staged, then don't calculate measured-computed values or
    // fill design matrix.  This will be done during an adjustment
    // via AdjustPhasedForward().
    if (buildnewMatrices && projectSettings_.a.stage)
        return;
 
    // For all adjustment modes, when this method is called during an adjustment
    // to update the normals, only the the measured-computed values need to be 
    // updated.  This is because the (Jacobian) design matrix elements for GPS
    // are unity (1 or -1) and do not change as coordinates are updated (unlike 
    // the Jacobian elements formed for other measurements).  Hence, for all 
    // adjustment modes except staged, the design matrix is updated once via
    // PrepareAdjustment.  For staged adjustments, the design matrix is updated
    // on each iteration.
 
    // Add X elements to measured minus computed
    AddMsrtoMeasMinusComp(_it_msr, design_row, 
        (estimatedStations->get(stn2, 0) - estimatedStations->get(stn1, 0)), 
        measMinusComp);
 
    if (buildnewMatrices || projectSettings_.a.stage)
    {
        // Add X elements to design matrix
        AddElementtoDesign(design_row, stn1, -1., design);        // X1
        AddElementtoDesign(design_row, stn2, 1., design);     // X2
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
    }
 
    // move to Y element
    design_row++;
    (*_it_msr)++;
 
    // Add Y elements to measured minus computed
    AddMsrtoMeasMinusComp(_it_msr, design_row, 
        (estimatedStations->get(stn2+1, 0) - estimatedStations->get(stn1+1, 0)), 
        measMinusComp, false);
            
    if (buildnewMatrices || projectSettings_.a.stage)
    {
        // Add Y elements to design matrix
        AddElementtoDesign(design_row, stn1+1, -1., design);  // Y1
        AddElementtoDesign(design_row, stn2+1, 1., design);       // Y2
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
    }
        
    // move to Z element
    design_row++;
    (*_it_msr)++;
    
    // Add Z elements to measured minus computed
    AddMsrtoMeasMinusComp(_it_msr, design_row, 
        (estimatedStations->get(stn2+2, 0) - estimatedStations->get(stn1+2, 0)), 
        measMinusComp, false);
        
    if (buildnewMatrices || projectSettings_.a.stage)
    {
        // Add Z elements to design matrix
        AddElementtoDesign(design_row, stn1+2, -1., design);  // Z1
        AddElementtoDesign(design_row, stn2+2, 1., design);       // Z2
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
    }
}

References AddElementtoDesign(), AddMsrtoMeasMinusComp(), dynadjust::math::matrix_2d::get(), and projectSettings_.

Referenced by UpdateDesignNormalMeasMatrices_G(), and UpdateDesignNormalMeasMatrices_X().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_G()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_G	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6356 of file dnaadjust.cpp.

{
    it_vmsr_t _it_msr_first(*_it_msr);
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
    UINT32 design_row_begin(design_row);
    
    UpdateDesignMeasMatrices_GX(_it_msr, design_row,
            measMinusComp, estimatedStations, design,
            stn1, stn2, buildnewMatrices);
 
    // For all adjustment modes except staged, when this method is called during 
    // an adjustment to update the normals, the weighted design matrix (AtVinv)
    // is not updated.  This is because the (Jacobian) design matrix elements for 
    // GPS are unity (1 or -1) and do not change as coordinates are updated (unlike 
    // the Jacobian elements formed for other measurements).  For all adjustment
    // modes except staged, the weighted design matrix and normals are updated once
    // via PrepareAdjustment.  For staged adjustments, the weighted design matrix 
    // and normals are updated on each iteration.
 
 
    // For first time run or staged adjustment mode
    if (buildnewMatrices || projectSettings_.a.stage)
    {
        // Load GPS Variance matrix.  For the first run, scaling is applied
        // and the variances are written to the binary measurements list.
        matrix_2d var_cart(3, 3);
        LoadVarianceMatrix_G(_it_msr_first, &var_cart);
 
        if (buildnewMatrices && projectSettings_.a.stage)
            return;
    
        // Build  At * V-1
        AtVinv->replace(stn1, design_row_begin, var_cart * -1);
        AtVinv->replace(stn2, design_row_begin, var_cart);
 
        if (!projectSettings_.a.stage)
            // Add weighted measurement contributions to normal matrix
            UpdateNormals_G(stn1, stn2, design_row_begin, normals, AtVinv);
    }
    
    design_row++;
}

References GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), LoadVarianceMatrix_G(), projectSettings_, dynadjust::math::matrix_2d::replace(), UpdateDesignMeasMatrices_GX(), and UpdateNormals_G().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_H()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_H	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6972 of file dnaadjust.cpp.

{
    // Initialise measurement.  No need to test if no further calculations are 
    // required (as in stage mode), as this is done later (below)
    InitialiseMeasurement(_it_msr, buildnewMatrices);
 
    if (buildnewMatrices)
    {
        it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    
        // N value available?
        if (fabs(stn1_it->geoidSep) > PRECISION_1E4)
        {
            // reduce to ellipsoidal height
            (*_it_msr)->preAdjCorr = stn1_it->geoidSep;
            (*_it_msr)->term1 += (*_it_msr)->preAdjCorr;
        }
 
        if (projectSettings_.a.stage)
            return;
    }
 
    UpdateDesignNormalMeasMatrices_HR(_it_msr, design_row, block,
        measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
}

References bstBinaryRecords_, InitialiseMeasurement(), PRECISION_1E4(), projectSettings_, and UpdateDesignNormalMeasMatrices_HR().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_HR()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_HR	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 7001 of file dnaadjust.cpp.

{
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    
    // Zn is the z coordinate element of the point on the z-axis 
    // which intersects with the the normal at the given Latitude
    double nu1, Zn1;
 
    // calculated height
    double comp_msr(EllipsoidHeight<double>(
        estimatedStations->get(stn1, 0), 
        estimatedStations->get(stn1+1, 0),
        estimatedStations->get(stn1+2, 0),
        stn1_it->currentLatitude,
        &nu1, &Zn1, 
        datum_.GetEllipsoidRef()));
    
    // Add measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, comp_msr, measMinusComp);
 
    // design matrix dR/dX1
    AddElementtoDesign(design_row, stn1, estimatedStations->get(stn1, 0)/(nu1+comp_msr), design);          // X1
 
    // design matrix dR/dY1
    AddElementtoDesign(design_row, stn1+1, estimatedStations->get(stn1+1, 0)/(nu1+comp_msr), design);      // Y1
 
    // design matrix dR/dZ1
    AddElementtoDesign(design_row, stn1+2, (estimatedStations->get(stn1+2, 0)+Zn1)/(nu1+comp_msr), design);    // Z1
    
    // Update AtVinv based on new design matrix elements
    UpdateAtVinv(_it_msr, stn1, 0, 0, design_row, design, AtVinv, buildnewMatrices);
    
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_HIJPQR(stn1, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddElementtoDesign(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, datum_, EllipsoidHeight(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), UpdateAtVinv(), and UpdateNormals_HIJPQR().

Referenced by UpdateDesignNormalMeasMatrices_H(), and UpdateDesignNormalMeasMatrices_R().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_I()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_I	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6789 of file dnaadjust.cpp.

{
    // Initialise measurement.  No need to test if no further calculations are 
    // required (as in stage mode), as this is done later (below)
    InitialiseMeasurement(_it_msr, buildnewMatrices);
 
    if (buildnewMatrices)
    {
        it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    
        // deflections available?
        if (fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
        {
            (*_it_msr)->preAdjCorr = stn1_it->meridianDef;                      // deflection in the prime meridian
            (*_it_msr)->term1 -= (*_it_msr)->preAdjCorr;                        // apply deflection correction
        }
        else
            (*_it_msr)->preAdjCorr = 0.0;
 
        if (projectSettings_.a.stage)
            return;
    }    
 
    UpdateDesignNormalMeasMatrices_IP(_it_msr, design_row, block,
        measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
}

References bstBinaryRecords_, E4_SEC_DEFLECTION(), InitialiseMeasurement(), projectSettings_, and UpdateDesignNormalMeasMatrices_IP().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_IP()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_IP	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6864 of file dnaadjust.cpp.

{
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    
    // Due to the lack of an explicit relationship between latitude and cartesian elements,
    // use mechanical differentiation.
    double latitude;
    // partial derivative for x
    double partialDerivative = PartialD_Latitude_F(
        estimatedStations->get(stn1, 0),     // X1
        estimatedStations->get(stn1+1, 0),       // Y1
        estimatedStations->get(stn1+2, 0),       // Z1
        x_element,                             // compute for X
        &latitude, 
        datum_.GetEllipsoidRef());
    AddElementtoDesign(design_row, stn1, partialDerivative, 
        design);                                // X
 
    // Update measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, latitude, measMinusComp);
 
    // partial derivative for Y
    partialDerivative = PartialD_Latitude(
        estimatedStations->get(stn1, 0),     // X1
        estimatedStations->get(stn1+1, 0),       // Y1
        estimatedStations->get(stn1+2, 0),       // Z1
        y_element,                             // compute for Y
        latitude, 
        datum_.GetEllipsoidRef());
    AddElementtoDesign(design_row, stn1+1, partialDerivative, 
        design);                                // Y
 
    // partial derivative for Z
    partialDerivative = PartialD_Latitude(
        estimatedStations->get(stn1, 0),     // X1
        estimatedStations->get(stn1+1, 0),       // Y1
        estimatedStations->get(stn1+2, 0),       // Z1
        z_element,                             // compute for Z
        latitude, 
        datum_.GetEllipsoidRef());
    AddElementtoDesign(design_row, stn1+2, partialDerivative, 
        design);                                // Z
 
    // Update AtVinv based on new design matrix elements
    UpdateAtVinv(_it_msr, stn1, 0, 0, design_row, design, AtVinv, buildnewMatrices);
    
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_HIJPQR(stn1, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddElementtoDesign(), AddMsrtoMeasMinusComp(), datum_, dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), PartialD_Latitude(), PartialD_Latitude_F(), UpdateAtVinv(), UpdateNormals_HIJPQR(), x_element, y_element, and z_element.

Referenced by UpdateDesignNormalMeasMatrices_I(), and UpdateDesignNormalMeasMatrices_P().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_J()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_J	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6819 of file dnaadjust.cpp.

{
    // Initialise measurement.  No need to test if no further calculations are 
    // required (as in stage mode), as this is done later (below)
    InitialiseMeasurement(_it_msr, buildnewMatrices);
 
    if (buildnewMatrices)
    {
        it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    
        // deflections available?
        if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION)
        {
            (*_it_msr)->preAdjCorr =                                        // deflection in the prime vertical
                stn1_it->verticalDef / cos(stn1_it->currentLatitude);       // sec(a) = 1/cos(a)
            (*_it_msr)->term1 -= (*_it_msr)->preAdjCorr;                    // apply deflection correction
        }
        else
            (*_it_msr)->preAdjCorr = 0.0;
 
        if (projectSettings_.a.stage)
            return;
    }    
 
    UpdateDesignNormalMeasMatrices_JQ(_it_msr, design_row, block,
        measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
}

References bstBinaryRecords_, E4_SEC_DEFLECTION(), InitialiseMeasurement(), projectSettings_, and UpdateDesignNormalMeasMatrices_JQ().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_JQ()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_JQ	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6934 of file dnaadjust.cpp.

{
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    
    // Add measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, stn1_it->currentLongitude, measMinusComp);
 
    // xy / (x^2 + y^2)^1.5
    double term1(estimatedStations->get(stn1, 0) * estimatedStations->get(stn1+1, 0) / 
        pow(estimatedStations->get(stn1, 0) * estimatedStations->get(stn1, 0) +
        estimatedStations->get(stn1+1, 0) * estimatedStations->get(stn1+1, 0), 1.5));
 
    // design matrix dlambda/dX1
    AddElementtoDesign(design_row, stn1, term1 * -1. / cos(stn1_it->currentLongitude), design);   // X1
 
    // design matrix dlambda/dY1
    AddElementtoDesign(design_row, stn1+1, term1 / sin(stn1_it->currentLongitude), design);       // Y1
 
    // design matrix dlambda/dZ1
    // the differentiation dlambda/dZ1 is undefined as longitude is not related
    // to the Z-coordinate. So use zero.
    AddElementtoDesign(design_row, stn1+2, 0., design);                                           // Z1
    
    // Update AtVinv based on new design matrix elements
    UpdateAtVinv(_it_msr, stn1, 0, 0, design_row, design, AtVinv, buildnewMatrices);
    
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_HIJPQR(stn1, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddElementtoDesign(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), UpdateAtVinv(), and UpdateNormals_HIJPQR().

Referenced by UpdateDesignNormalMeasMatrices_J(), and UpdateDesignNormalMeasMatrices_Q().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_L()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_L	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6720 of file dnaadjust.cpp.

{
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    // Zn is the z coordinate element of the point on the z-axis 
    // which intersects with the the normal at the given Latitude
    double h1, h2, nu1, nu2, Zn1, Zn2;
 
    // calculated diff height
    double comp_msr(EllipsoidHeightDifference<double>(
        estimatedStations->get(stn1, 0), 
        estimatedStations->get(stn1+1, 0),
        estimatedStations->get(stn1+2, 0),
        estimatedStations->get(stn2, 0),
        estimatedStations->get(stn2+1, 0),
        estimatedStations->get(stn2+2, 0),
        stn1_it->currentLatitude,
        stn2_it->currentLatitude,
        &h1, &h2, &nu1, &nu2, &Zn1, &Zn2, 
        datum_.GetEllipsoidRef()));
 
    // Initialise measurement.  No need to test if no further calculations are 
    // required (as in stage mode), as this is done later (below)
    InitialiseMeasurement(_it_msr, buildnewMatrices);
 
    if (buildnewMatrices)
    {
        // N value available?
        if (fabs(stn1_it->geoidSep) > PRECISION_1E4 ||
            fabs(stn2_it->geoidSep) > PRECISION_1E4)
        {
            // Reduce to ellipsoidal difference
            (*_it_msr)->preAdjCorr = stn2_it->geoidSep - stn1_it->geoidSep;
            (*_it_msr)->term1 += (*_it_msr)->preAdjCorr;                        
        }           
 
        if (projectSettings_.a.stage)
            return;
    }
 
    // Update measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, comp_msr, measMinusComp);
 
    // Add partial derivatives dA/dX1, dA/dY1, dA/dZ1, dA/dX2, dA/dY2, dA/dZ2 to design matrix
    AddMsrtoDesign_L(design_row, stn1, stn2,
        -estimatedStations->get(stn1, 0)/(nu1+h1), 
        -estimatedStations->get(stn1+1, 0)/(nu1+h1),
        -(estimatedStations->get(stn1+2, 0)+Zn1)/(nu1+h1),
        estimatedStations->get(stn2, 0)/(nu2+h2),
        estimatedStations->get(stn2+1, 0)/(nu2+h2),
        (estimatedStations->get(stn2+2, 0)+Zn2)/(nu2+h2),
        design);
 
    // Update AtVinv based on new design matrix elements
    UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddMsrtoDesign_L(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, datum_, EllipsoidHeightDifference(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), InitialiseMeasurement(), PRECISION_1E4(), projectSettings_, UpdateAtVinv(), and UpdateNormals_BCEKLMSVZ().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_M()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_M	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6403 of file dnaadjust.cpp.

{
    // Initialise measurement and test if no further calculations are 
    // required (as in stage mode)
    if (InitialiseMeasurement(_it_msr, buildnewMatrices))
        return;
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    // Note: Each measured MSL arc is reduced to an ellipsoid chord on the first run.
    // However, to cater for (potentially) large changes in latitude and longitude, recompute the
    // chord using the original measurement
 
    // Reduce MSL arc to ellipsoid chord
    (*_it_msr)->term1 = MSLArctoEllipsoidChord<double>(
        (*_it_msr)->preAdjMeas,                                 // use measured MSL arc
        stn1_it->currentLatitude, stn2_it->currentLatitude,
        stn1_it->geoidSep, stn2_it->geoidSep,
        datum_.GetEllipsoidRef());
 
    (*_it_msr)->preAdjCorr = (*_it_msr)->term1 - (*_it_msr)->preAdjMeas;
 
    // Now that the MSL arc has been reduced to a chord, call UpdateDesignNormalMeasMatrices_CEM
    UpdateDesignNormalMeasMatrices_CEM(_it_msr, design_row, block,
        measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
}

References bstBinaryRecords_, datum_, InitialiseMeasurement(), MSLArctoEllipsoidChord(), and UpdateDesignNormalMeasMatrices_CEM().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_P()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_P	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6850 of file dnaadjust.cpp.

{
    // Initialise measurement and test if no further calculations are 
    // required (as in stage mode)
    if (InitialiseMeasurement(_it_msr, buildnewMatrices))
        return;
 
    UpdateDesignNormalMeasMatrices_IP(_it_msr, design_row, block,
        measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
}

References InitialiseMeasurement(), and UpdateDesignNormalMeasMatrices_IP().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_Q()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_Q	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6920 of file dnaadjust.cpp.

{
    // Initialise measurement and test if no further calculations are 
    // required (as in stage mode)
    if (InitialiseMeasurement(_it_msr, buildnewMatrices))
        return;
 
    UpdateDesignNormalMeasMatrices_JQ(_it_msr, design_row, block,
        measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
}

References InitialiseMeasurement(), and UpdateDesignNormalMeasMatrices_JQ().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_R()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_R	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 7045 of file dnaadjust.cpp.

{
    // Initialise measurement and test if no further calculations are 
    // required (as in stage mode)
    if (InitialiseMeasurement(_it_msr, buildnewMatrices))
        return;
 
    UpdateDesignNormalMeasMatrices_HR(_it_msr, design_row, block,
        measMinusComp, estimatedStations, normals, design, AtVinv, buildnewMatrices);
}

References InitialiseMeasurement(), and UpdateDesignNormalMeasMatrices_HR().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_S()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_S	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6440 of file dnaadjust.cpp.

{
    // preAdjMeas is used to store original measured MSL arc distance
    if (buildnewMatrices)
    {
        // This is the first time adjust has run, so
        // back up the raw measurement
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
        if (projectSettings_.a.stage)
            return;
    }
 
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
 
    // compute dX, dY, dZ for instrument height (ih) and target height (th)
    double dXih, dYih, dZih, dXth, dYth, dZth;
    CartesianElementsFromInstrumentHeight((*_it_msr)->term3,               // instrument height
        &dXih, &dYih, &dZih, 
        stn1_it->currentLatitude,
        stn1_it->currentLongitude);
    CartesianElementsFromInstrumentHeight((*_it_msr)->term4,               // target height
        &dXth, &dYth, &dZth,
        stn1_it->currentLatitude,
        stn1_it->currentLongitude);
 
    // compute distance between instrument and target, taking into consideration
    // instrument height, target height, and vector between stations
    double dX(estimatedStations->get(stn2, 0) - estimatedStations->get(stn1, 0) + dXth - dXih);
    double dY(estimatedStations->get(stn2+1, 0) - estimatedStations->get(stn1+1, 0) + dYth - dYih);
    double dZ(estimatedStations->get(stn2+2, 0) - estimatedStations->get(stn1+2, 0) + dZth - dZih);
 
    // calculated distance
    double comp_msr(magnitude(dX, dY, dZ));
 
    // Add measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, comp_msr, measMinusComp);
 
    // Add partial derivatives dA/dX1, dA/dY1, dA/dZ1 to design matrix
    AddMsrtoDesign_BCEKMSVZ(design_row, stn1, stn2,
        -dX/comp_msr, -dY/comp_msr, -dZ/comp_msr,
        design);
 
    // Update AtVinv based on new design matrix elements
    UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddMsrtoDesign_BCEKMSVZ(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, CartesianElementsFromInstrumentHeight(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), magnitude(), projectSettings_, UpdateAtVinv(), and UpdateNormals_BCEKLMSVZ().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_V()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_V	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6507 of file dnaadjust.cpp.

{
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    double local_12e, local_12n, local_12up;
 
    // Initialise measurement.  No need to test if no further calculations are 
    // required (as in stage mode), as this is done later (below)
    InitialiseMeasurement(_it_msr, buildnewMatrices);
 
    if (buildnewMatrices)
    {
        // deflections available?
        if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
        {
            // Correct for deflection of the vertical
            // 1. compute bearing from estimated coordinates
            double azimuth(Direction(
                estimatedStations->get(stn1, 0),     // X1
                estimatedStations->get(stn1+1, 0),       // Y1
                estimatedStations->get(stn1+2, 0),       // Z1
                estimatedStations->get(stn2, 0),         // X2
                estimatedStations->get(stn2+1, 0),       // Y2
                estimatedStations->get(stn2+2, 0),       // Z2
                stn1_it->currentLatitude,
                stn1_it->currentLongitude));
        
            // 2. Compute correction
            (*_it_msr)->preAdjCorr = ZenithDeflectionCorrection<double>(      // Correction to zenith distance for deflection of vertical
                azimuth,                                                        // geodetic azimuth
                stn1_it->verticalDef,                                           // deflection in prime vertical
                stn1_it->meridianDef);                                          // deflection in prime meridian
 
            (*_it_msr)->term1 += (*_it_msr)->preAdjCorr;                        // apply deflection correction
        }
        else
            (*_it_msr)->preAdjCorr = 0.0;
 
        if (projectSettings_.a.stage)
            return;
    }
 
    // compute zenith distance from estimated coordinates
    double comp_msr(ZenithDistance(
        estimatedStations->get(stn1, 0),                 // X1
        estimatedStations->get(stn1+1, 0),                   // Y1
        estimatedStations->get(stn1+2, 0),                   // Z1
        estimatedStations->get(stn2, 0),                     // X2
        estimatedStations->get(stn2+1, 0),                   // Y2
        estimatedStations->get(stn2+2, 0),                   // Z2
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        stn2_it->currentLatitude,
        stn2_it->currentLongitude,
        (*_it_msr)->term3,                                  // instrument height
        (*_it_msr)->term4,                                  // target height
        &local_12e,                                         // local_12e, ..12n, ..12up represent
        &local_12n,                                         // the geometric difference between
        &local_12up));                                      // station1 and station2
    
    // Update measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, comp_msr, measMinusComp);
 
    // compute partial derivatives for normals
    double e2n2(local_12e*local_12e + local_12n*local_12n);
    double sqrt_e2n2(sqrt(e2n2));
    double se2n2_up2(sqrt_e2n2/(local_12up*local_12up));
    double up_se2n2(local_12up*sqrt_e2n2);
    double cos2v(cos(comp_msr)*cos(comp_msr));
    double cos_lat(cos(stn1_it->currentLatitude));
    double sin_lat(sin(stn1_it->currentLatitude));
    double cos_long(cos(stn1_it->currentLongitude));
    double sin_long(sin(stn1_it->currentLongitude));
 
    // Add partial derivatives dA/dX1, dA/dY1, dA/dZ1 to design matrix
    AddMsrtoDesign_BCEKMSVZ(design_row, stn1, stn2,
        cos2v * (((local_12e * sin_long + local_12n * sin_lat * cos_long) / up_se2n2) + cos_lat * cos_long * se2n2_up2),
        cos2v * (((-local_12e * cos_long + local_12n * sin_lat * sin_long) / up_se2n2) + cos_lat * sin_long * se2n2_up2),   
        cos2v * ((-local_12n * cos_lat / up_se2n2) + sin_lat * se2n2_up2),
        design);
 
    // Update AtVinv based on new design matrix elements
    UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddMsrtoDesign_BCEKMSVZ(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, Direction(), E4_SEC_DEFLECTION(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), InitialiseMeasurement(), projectSettings_, UpdateAtVinv(), UpdateNormals_BCEKLMSVZ(), ZenithDeflectionCorrection(), and ZenithDistance().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_X()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_X	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 7059 of file dnaadjust.cpp.

{
    it_vmsr_t _it_msr_first(*_it_msr);
 
    UINT32 stn1, stn2, covr(0), covc(0);
    
    UINT32 cluster_bsl, baseline_count((*_it_msr)->vectorCount1);
    UINT32 covariance_count;
    UINT32 design_row_begin(design_row);
        
    for (cluster_bsl=0; cluster_bsl<baseline_count; ++cluster_bsl)  // number of baselines/points
    {
        stn1 = GetBlkMatrixElemStn1(block, _it_msr); 
        stn2 = GetBlkMatrixElemStn2(block, _it_msr);
 
        UpdateDesignMeasMatrices_GX(_it_msr, design_row,
            measMinusComp, estimatedStations, design,
            stn1, stn2, buildnewMatrices);
 
        design_row++;
        
        covariance_count = (*_it_msr)->vectorCount2;
                
        // skip covariances until next point
        (*_it_msr) += covariance_count * 3;
        
        if (covariance_count > 0)
            (*_it_msr)++;
 
        if (projectSettings_.g.verbose > 5)
            debug_file << std::endl;
    }
 
    matrix_2d var_cart(baseline_count * 3, baseline_count * 3);
 
    if (buildnewMatrices || projectSettings_.a.stage)
    {
        // Load apriori variance matrix, and assign to binary measurement
        // If required, apply scalars
        LoadVarianceMatrix_X(_it_msr_first, &var_cart);
 
        if (buildnewMatrices && projectSettings_.a.stage)
            return;
    }
 
    // If this method is called via PrepareAdjustment() and the adjustment 
    // mode is staged, then don't update the AtVinv matrix.  This will be
    // done during an adjustment via AdjustPhasedForward().
    if (!buildnewMatrices && !projectSettings_.a.stage)
        return;
 
    UINT32 cluster_cov;
 
    it_vmsr_t _it_msr_temp(_it_msr_first);
    vUINT32 baseline_stations;
 
    baseline_stations.push_back(GetBlkMatrixElemStn1(block, &_it_msr_temp));
    baseline_stations.push_back(GetBlkMatrixElemStn2(block, &_it_msr_temp));
    std::sort(baseline_stations.begin(), baseline_stations.end());
 
    covc = baseline_count * 3;
    matrix_2d tmp(3, covc);
 
    // Build  At * V-1
    for (cluster_bsl=0; cluster_bsl<baseline_count; ++cluster_bsl)
    {
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr_temp);
        stn2 = GetBlkMatrixElemStn2(block, &_it_msr_temp);
    
        // create a unique list of stations used in this cluster
        if (!binary_search(baseline_stations.begin(), baseline_stations.end(), stn1))
        {
            baseline_stations.push_back(stn1);
            std::sort(baseline_stations.begin(), baseline_stations.end());
        }
 
        if (!binary_search(baseline_stations.begin(), baseline_stations.end(), stn2))
        {
            baseline_stations.push_back(stn2);
            std::sort(baseline_stations.begin(), baseline_stations.end());
        }
 
        covr = cluster_bsl * 3;
        //covc = baseline_count * 3;
 
        // add variances/covariances for this baseline to At * V-1
        //AtVinv->blockadd(stn1, design_row_begin, 
        //  var_cart.submatrix(covr, 
        //  0, 3, covc).scale(-1.), 0, 0, 3, covc);                     // add entire row of this vcv
        
        // copy the relevant var_cart elements to temp and multiply 
        // by -1 to effect the design matrix elements
        var_cart.submatrix(covr, 0, &tmp, 3, covc);
        tmp.scale(-1.);
        // add variances/covariances for this baseline to At * V-1
        AtVinv->blockadd(stn1, design_row_begin, 
            tmp, 0, 0, 3, covc);                                        // add entire row of this vcv       
        AtVinv->blockadd(stn2, design_row_begin, 
            var_cart, covr, 0, 3, covc);                                // add entire row of this vcv
        
        covariance_count = _it_msr_temp->vectorCount2;
        _it_msr_temp += 3;          // move to covariances
        
        for (cluster_cov=0; cluster_cov<covariance_count; ++cluster_cov)
            _it_msr_temp += 3;
    }
 
    if (projectSettings_.a.stage)
        return;
    
    _it_msr_temp = _it_msr_first;
    
    matrix_2d tmp0(3, 3);
 
    // Build  At * V-1 * A variances
    for (cluster_bsl=0; cluster_bsl<baseline_count; ++cluster_bsl)
    {
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr_temp);
        stn2 = GetBlkMatrixElemStn2(block, &_it_msr_temp);
    
        covr = cluster_bsl * 3;
        //v_normals_.at(block).blockadd(stn1, stn1,                     // Station 1.  This variance matrix
        //  AtVinv->submatrix(stn1,                                     // component must be multiplied by -1 to
        //      design_row_begin+covr, 3, 3).scale(-1.), 0, 0, 3, 3);   // effect the design matrix elements
        
        // copy the relevant var_cart elements to temp and multiply 
        // by -1 to effect the design matrix elements
        AtVinv->submatrix(stn1, design_row_begin+covr, &tmp0, 3, 3);
        tmp0.scale(-1.);
 
        // add variances for these stations
        v_normals_.at(block).blockadd(stn1, stn1,                     // Station 1.
            tmp0, 0, 0, 3, 3);
        v_normals_.at(block).blockadd(stn2, stn2,                     // Station 2
            v_AtVinv_.at(block), stn2, design_row_begin+covr, 3, 3);   
 
        covariance_count = _it_msr_temp->vectorCount2;
        _it_msr_temp += 3;          // move to covariances
 
        // add covariances for these stations
        for (cluster_cov=0; cluster_cov<covariance_count; ++cluster_cov)
            _it_msr_temp += 3;
    }
 
    matrix_2d tmp1(3, baseline_count*3), tmp2(baseline_count*3, 3);
 
    // Build  At * V-1 * A covariances
    for (cluster_bsl=0; cluster_bsl<baseline_stations.size(); ++cluster_bsl)
    {
        stn1 = baseline_stations.at(cluster_bsl);
 
        for (cluster_cov=0; cluster_cov<baseline_stations.size(); ++cluster_cov)
        {
            if (cluster_cov==cluster_bsl)
                continue;
 
            stn2 = baseline_stations.at(cluster_cov);
            //v_normals_.at(block).blockadd(stn1, stn2,     
            //  AtVinv->submatrix(stn1,         
            //      design_row_begin, 3, baseline_count*3).multiply(
            //          design->submatrix(design_row_begin, stn2, 
            //              baseline_count*3, 3)), 0, 0, 3, 3);
 
            // The following is more code, but is more efficient as it
            // recycles matrix instances (as opposed to creating a
            // new instance for every call to submatrix and multiply)
            // Get AtVinv component
            AtVinv->submatrix(stn1, design_row_begin, 
                &tmp1, 3, baseline_count*3);
            // Get design component
            design->submatrix(design_row_begin, stn2, 
                &tmp2, baseline_count*3, 3);
            // multiply the components to form covariance
            // for stations stn1 and stn2
            //tmp0.multiply(tmp1, tmp2);
            tmp0.multiply(tmp1, "N", tmp2, "N");
            // Now add covariances to normals
            v_normals_.at(block).blockadd(stn1, stn2,     
                tmp0, 0, 0, 3, 3);
        }
    }
}

References dynadjust::math::matrix_2d::blockadd(), debug_file, GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), LoadVarianceMatrix_X(), dynadjust::math::matrix_2d::multiply(), projectSettings_, dynadjust::math::matrix_2d::scale(), dynadjust::math::matrix_2d::submatrix(), UpdateDesignMeasMatrices_GX(), v_AtVinv_, and v_normals_.

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_Y()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_Y	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 7249 of file dnaadjust.cpp.

{
    it_vmsr_t _it_msr_first(*_it_msr);
    it_vmsr_t tmp_msr;
 
    UINT32 stn1, covr(0), covc(0);
    
    UINT32 cluster_pnt, point_count((*_it_msr)->vectorCount1);
    UINT32 covariance_count;
    UINT32 design_row_begin(design_row);
    
    // the following is required in the case when Y cluster coordinates are LLH
    double latitude, longitude, ellipsoidHeight, x, y, z;
        
    it_vstn_t stn1_it;
 
    _COORD_TYPE_ coordType(CDnaStation::GetCoordTypeC((*_it_msr)->coordType));
 
    for (cluster_pnt=0; cluster_pnt<point_count; ++cluster_pnt)
    {
        covr = cluster_pnt * 3;
        covariance_count = (*_it_msr)->vectorCount2;
 
        stn1_it = bstBinaryRecords_.begin() + (*_it_msr)->station1;
    
        tmp_msr = *_it_msr;
 
        stn1 = GetBlkMatrixElemStn1(block, _it_msr);
 
        // Convert to cartesian reference frame?
        if (coordType == LLH_type_i)
        {
            // This section (and others in this function where coordType == LLH_type_i) 
            // will only be performed once because this measurement will be converted 
            // to XYZ and coordType will be set to XYZ_type_i
 
            // Get latitude value
            latitude = tmp_msr->term1;
            // retain original value
            tmp_msr->preAdjMeas = tmp_msr->term1;
            tmp_msr++;
 
            // Get longitude value
            longitude = tmp_msr->term1; 
            // retain original value
            tmp_msr->preAdjMeas = tmp_msr->term1;
            tmp_msr++;
 
            // Get height
            // NOTE: heights for Y clusters are orthometric.
            // Retain original value
            ellipsoidHeight = tmp_msr->term1;
            tmp_msr->preAdjMeas = tmp_msr->term1;
 
            // Reduce to ellipsoid height
            if (fabs(stn1_it->geoidSep) > PRECISION_1E4)
            {
                tmp_msr->preAdjCorr = stn1_it->geoidSep;
                ellipsoidHeight += tmp_msr->preAdjCorr;             
            }
 
            // convert
            GeoToCart<double>(latitude, longitude, ellipsoidHeight, 
                &x, &y, &z, 
                datum_.GetEllipsoidRef());
 
            // Update bms record
            (*_it_msr)->term1 = x;
            snprintf((*_it_msr)->coordType, sizeof((*_it_msr)->coordType), "%s", XYZ_type);
 
            // retain original reference frame
            (*_it_msr)->station3 = LLH_type_i;
        }
 
        // If this method is called via PrepareAdjustment() and the adjustment 
        // mode is staged, then don't calculate measured-computed values or
        // fill design matrix.  This will be done during an adjustment
        // via AdjustPhasedForward().
        if (!(buildnewMatrices && projectSettings_.a.stage))
        {
            // For all adjustment modes, when this method is called during an adjustment
            // to update the normals, only the the measured-computed values need to be 
            // updated.  This is because the (Jacobian) design matrix elements for GPS
            // are unity (1 or -1) and do not change as coordinates are updated (unlike 
            // the Jacobian elements formed for other measurements).  Hence, for all 
            // adjustment modes except staged, the design matrix is updated once via
            // PrepareAdjustment.  For staged adjustments, the design matrix is updated
            // on each iteration.
 
            // Add X element to measured minus computed
            AddMsrtoMeasMinusComp(_it_msr, design_row, 
                estimatedStations->get(stn1, 0), 
                measMinusComp);
        
            if (buildnewMatrices || projectSettings_.a.stage)
                // Add X elements to design matrix
                AddElementtoDesign(design_row, stn1, 1., design);     // X
            
            design_row++;
        }
 
        if (buildnewMatrices)
            if (coordType != LLH_type_i && (*_it_msr)->station3 != LLH_type_i)
                (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
        // move to Y element
        (*_it_msr)++;
 
        // measurements matrix Y
        if (coordType == LLH_type_i)
        {
            // Update bms record
            (*_it_msr)->term1 = y;
            snprintf((*_it_msr)->coordType, sizeof((*_it_msr)->coordType), "%s", XYZ_type);
 
            // retain original reference frame
            (*_it_msr)->station3 = LLH_type_i;
        }
 
        // If this method is called via PrepareAdjustment() and the adjustment 
        // mode is staged, then don't calculate measured-computed values or
        // fill design matrix.  This will be done during an adjustment
        // via AdjustPhasedForward().
        if (!(buildnewMatrices && projectSettings_.a.stage))
        {
            // For all adjustment modes, when this method is called during an adjustment
            // to update the normals, only the the measured-computed values need to be 
            // updated.  This is because the (Jacobian) design matrix elements for GPS
            // are unity (1 or -1) and do not change as coordinates are updated (unlike 
            // the Jacobian elements formed for other measurements).  Hence, for all 
            // adjustment modes except staged, the design matrix is updated once via
            // PrepareAdjustment.  For staged adjustments, the design matrix is updated
            // on each iteration.
 
            // Add Y element to measured minus computed
            AddMsrtoMeasMinusComp(_it_msr, design_row, 
                estimatedStations->get(stn1+1, 0),
                measMinusComp, false);
        
            if (buildnewMatrices || projectSettings_.a.stage)
                // Add Y elements to design matrix
                AddElementtoDesign(design_row, stn1+1, 1., design);       // Y
 
            design_row++;
        }
 
        if (buildnewMatrices)
            if (coordType != LLH_type_i && (*_it_msr)->station3 != LLH_type_i)
                (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
        // move to Z element
        (*_it_msr)++;
 
        // measurements matrix Z
        if (coordType == LLH_type_i)
        {
            // Update bms record
            (*_it_msr)->term1 = z;
            snprintf((*_it_msr)->coordType, sizeof((*_it_msr)->coordType), "%s", XYZ_type);
 
            // retain original reference frame
            (*_it_msr)->station3 = LLH_type_i;
        }
 
        // If this method is called via PrepareAdjustment() and the adjustment 
        // mode is staged, then don't calculate measured-computed values or
        // fill design matrix.  This will be done during an adjustment
        // via AdjustPhasedForward().
        if (!(buildnewMatrices && projectSettings_.a.stage))
        {
            // For all adjustment modes, when this method is called during an adjustment
            // to update the normals, only the the measured-computed values need to be 
            // updated.  This is because the (Jacobian) design matrix elements for GPS
            // are unity (1 or -1) and do not change as coordinates are updated (unlike 
            // the Jacobian elements formed for other measurements).  Hence, for all 
            // adjustment modes except staged, the design matrix is updated once via
            // PrepareAdjustment.  For staged adjustments, the design matrix is updated
            // on each iteration.
 
            // Add Z element to measured minus computed
            AddMsrtoMeasMinusComp(_it_msr, design_row, 
                estimatedStations->get(stn1+2, 0),
                measMinusComp, false);
        
            if (buildnewMatrices || projectSettings_.a.stage)
                // Add Z elements to design matrix
                AddElementtoDesign(design_row, stn1+2, 1., design);       // Z
 
            design_row++;
        }
 
        if (buildnewMatrices)
            if (coordType != LLH_type_i && (*_it_msr)->station3 != LLH_type_i)
                (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
        
        covariance_count = (*_it_msr)->vectorCount2;
                
        // skip covariances until next point
        (*_it_msr) += covariance_count * 3;
        
        if (covariance_count > 0)
            (*_it_msr)++;
    }
 
    matrix_2d var_cart(point_count * 3, point_count * 3);
 
    if (buildnewMatrices || projectSettings_.a.stage)
    {
        // Load apriori variance matrix, and assign to binary measurement
        // If required, propagate to cartesian reference frame and apply 
        // scalars
        LoadVarianceMatrix_Y(_it_msr_first, &var_cart, coordType);
    
        // If preparing for a stage adjustment, return
        // Normals will be built for each block as needed
        if (buildnewMatrices && projectSettings_.a.stage)
            return;
    }
    
    // If this method is called via PrepareAdjustment() and the adjustment 
    // mode is staged, then don't update the AtVinv matrix.  This will be
    // done during an adjustment via AdjustPhasedForward().
    if (!buildnewMatrices && !projectSettings_.a.stage)
        return;
 
    UINT32 cluster_cov;
 
    UINT32 stn2, cov_c;
    it_vmsr_t _it_msr_temp(_it_msr_first);
 
    // Build  At * V-1
    for (cluster_pnt=0; cluster_pnt<point_count; ++cluster_pnt)
    {       
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr_temp);
        covariance_count = _it_msr_temp->vectorCount2;
        
        covr = cluster_pnt * 3;
        covc = cluster_pnt * 3;
 
        // add variance for this station
        AtVinv->copyelements(stn1, design_row_begin, var_cart, covr, covc, 3, 3);
 
        if (covariance_count < 1)
            break;
 
        _it_msr_temp += 3;  // advance to first cluster point (if clusters exist, otherwise, next point)
        cov_c = 0;
 
        for (cluster_cov=0; cluster_cov<covariance_count; ++cluster_cov)        // number of baseline/point covariances
        {
            stn2 = GetBlkMatrixElemStn1(block, &_it_msr_temp);  // this becomes stn1 in next cluster_pnt loop
 
            covc += 3;
            cov_c += 3;
 
            // add covariance between stn1 and this station
            AtVinv->copyelements(stn1, design_row_begin + cov_c, var_cart, covr, covc, 3, 3);
            AtVinv->copyelements(stn2, design_row_begin, var_cart, covc, covr, 3, 3);
 
            _it_msr_temp += 3;
        }
 
        design_row_begin += 3;
    }
 
    if (projectSettings_.a.stage)
        return;
    
    _it_msr_temp = _it_msr_first;
 
    // Add to At * V-1 * A
    for (cluster_pnt=0; cluster_pnt<point_count; ++cluster_pnt)
    {       
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr_temp);
        covariance_count = _it_msr_temp->vectorCount2;
        
        covr = cluster_pnt * 3;
        covc = cluster_pnt * 3;
 
        // add variance for this station
        v_normals_.at(block).blockadd(stn1, stn1, var_cart, covr, covc, 3, 3);
 
        if (covariance_count < 1)
            break;
 
        _it_msr_temp += 3;
 
        for (cluster_cov=0; cluster_cov<covariance_count; ++cluster_cov)    // number of baseline/point covariances
        {
            stn2 = GetBlkMatrixElemStn1(block, &_it_msr_temp);      // this becomes stn1 in next cluster_pnt loop
            covc += 3;
 
            if (stn1 < stn2)
            {
                // add covariance between stn1 and this station
                v_normals_.at(block).blockadd(stn1, stn2, var_cart, covr, covc, 3, 3);
                v_normals_.at(block).blockadd(stn2, stn1, var_cart, covc, covr, 3, 3);
            }
            else
            {
                // Transpose
                // add covariance between stn1 and this station
                v_normals_.at(block).blockTadd(stn1, stn2, var_cart, covr, covc, 3, 3);
                v_normals_.at(block).blockTadd(stn2, stn1, var_cart, covc, covr, 3, 3);
            }
            _it_msr_temp += 3;
        }
    }
}

References AddElementtoDesign(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, dynadjust::math::matrix_2d::copyelements(), datum_, GeoToCart(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), dynadjust::measurements::CDnaStation::GetCoordTypeC(), LLH_type_i, LoadVarianceMatrix_Y(), PRECISION_1E4(), projectSettings_, v_normals_, and XYZ_type().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateDesignNormalMeasMatrices_Z()

void dynadjust::networkadjust::dna_adjust::UpdateDesignNormalMeasMatrices_Z	(	pit_vmsr_t	_it_msr,
		UINT32 &	design_row,
		const UINT32 &	block,
		matrix_2d *	measMinusComp,
		matrix_2d *	estimatedStations,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices )

private

Definition at line 6616 of file dnaadjust.cpp.

{
    UINT32 stn1(GetBlkMatrixElemStn1(block, _it_msr)); 
    UINT32 stn2(GetBlkMatrixElemStn2(block, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    double local_12e, local_12n, local_12up;
 
    // Initialise measurement.  No need to test if no further calculations are 
    // required (as in stage mode), as this is done later (below)
    InitialiseMeasurement(_it_msr, buildnewMatrices);
 
    if (buildnewMatrices)
    {
        // deflections available?
        if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
        {
            // Correct for deflection of the vertical
            // 1. compute bearing from estimated coordinates
            double azimuth(Direction(
                estimatedStations->get(stn1, 0),     // X1
                estimatedStations->get(stn1+1, 0),       // Y1
                estimatedStations->get(stn1+2, 0),       // Z1
                estimatedStations->get(stn2, 0),         // X2
                estimatedStations->get(stn2+1, 0),       // Y2
                estimatedStations->get(stn2+2, 0),       // Z2
                stn1_it->currentLatitude,
                stn1_it->currentLongitude));
        
            // 2. Compute correction
            (*_it_msr)->preAdjCorr = ZenithDeflectionCorrection<double>(      // Correction to vertical angle for deflection of vertical
                azimuth,                                                        // geodetic azimuth
                stn1_it->verticalDef,                                           // deflection in prime vertical
                stn1_it->meridianDef);                                          // deflection in prime meridian
            
            (*_it_msr)->term1 -= (*_it_msr)->preAdjCorr;                        // apply deflection correction
        }
        else
            (*_it_msr)->preAdjCorr = 0.0;
 
        if (projectSettings_.a.stage)
            return;
    }
 
    // compute vertical angle from estimated coordinates
    double comp_msr(VerticalAngle(
        estimatedStations->get(stn1, 0),                 // X1
        estimatedStations->get(stn1+1, 0),                   // Y1
        estimatedStations->get(stn1+2, 0),                   // Z1
        estimatedStations->get(stn2, 0),                     // X2
        estimatedStations->get(stn2+1, 0),                   // Y2
        estimatedStations->get(stn2+2, 0),                   // Z2
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        stn2_it->currentLatitude,
        stn2_it->currentLongitude,
        (*_it_msr)->term3,                                  // instrument height
        (*_it_msr)->term4,                                  // target height
        &local_12e,                                         // local_12e, ..12n, ..12up represent
        &local_12n,                                         // the geometric difference between
        &local_12up));                                      // station1 and station2
 
    // Update measured minus computed value
    AddMsrtoMeasMinusComp(_it_msr, design_row, comp_msr, measMinusComp);
 
    // compute partial derivative terms
    double e2n2(local_12e*local_12e + local_12n*local_12n);
    double sqrt_e2n2(sqrt(e2n2));
    double se2n2_d_e2n2(sqrt_e2n2/e2n2);
    double up_d_se2n2_e2n2(local_12up/(sqrt_e2n2*e2n2));
    double cos2v(cos(comp_msr)*cos(comp_msr));
    double cos_lat(cos(stn1_it->currentLatitude));
    double sin_lat(sin(stn1_it->currentLatitude));
    double cos_long(cos(stn1_it->currentLongitude));
    double sin_long(sin(stn1_it->currentLongitude));
 
    // Add partial derivatives dA/dX1, dA/dY1, dA/dZ1 to design matrix
    AddMsrtoDesign_BCEKMSVZ(design_row, stn1, stn2,
        cos2v * ((-cos_lat * cos_long * se2n2_d_e2n2) - ((local_12e * sin_long + local_12n * sin_lat * cos_long) * up_d_se2n2_e2n2)),
        cos2v * ((-cos_lat * sin_long * se2n2_d_e2n2) + ((local_12e * cos_long - local_12n * sin_lat * sin_long) * up_d_se2n2_e2n2)),
        cos2v * ((-sin_lat * se2n2_d_e2n2) + (local_12n * cos_lat * up_d_se2n2_e2n2)),
        design);
    
    // Update AtVinv based on new design matrix elements
    UpdateAtVinv(_it_msr, stn1, stn2, 0, design_row, design, AtVinv, buildnewMatrices);
 
    if (buildnewMatrices)
        // Add weighted measurement contributions to normal matrix
        UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
    else
        design_row++;
}

References AddMsrtoDesign_BCEKMSVZ(), AddMsrtoMeasMinusComp(), bstBinaryRecords_, Direction(), E4_SEC_DEFLECTION(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), InitialiseMeasurement(), projectSettings_, UpdateAtVinv(), UpdateNormals_BCEKLMSVZ(), VerticalAngle(), and ZenithDeflectionCorrection().

Referenced by UpdateDesignNormalMeasMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IgnoredMeasurementContainsInvalidStation()

bool dynadjust::networkadjust::dna_adjust::IgnoredMeasurementContainsInvalidStation ( pit_vmsr_t _it_msr )

private

Definition at line 12148 of file dnaadjust.cpp.

{
    UINT32 cluster_msr, covariance_count, cluster_count((*_it_msr)->vectorCount1);
 
    switch ((*_it_msr)->measType)
    {
    // Three station measurement
    case 'A':   // Horizontal angle
        if (vAssocStnList_.at((*_it_msr)->station3).IsInvalid())
            return false;
        [[fallthrough]];
    // Two station measurements
    case 'B':   // Geodetic azimuth
    case 'C':   // Chord dist
    case 'E':   // Ellipsoid arc
    case 'G':   // GPS Baseline
    case 'K':   // Astronomic azimuth
    case 'L':   // Level difference
    case 'M':   // MSL arc
    case 'S':   // Slope distance
    case 'V':   // Zenith distance
    case 'Z':   // Vertical angle
        if (vAssocStnList_.at((*_it_msr)->station2).IsInvalid())
            return false;
        [[fallthrough]];
    // One station measurements
    case 'H':   // Orthometric height
    case 'I':   // Astronomic latitude
    case 'J':   // Astronomic longitude
    case 'P':   // Geodetic latitude
    case 'Q':   // Geodetic longitude
    case 'R':   // Ellipsoidal height
        if (vAssocStnList_.at((*_it_msr)->station1).IsInvalid())
            return false;
        break;
    // GNSS measurements
    case 'X':   // GPS Baseline cluster
    case 'Y':   // GPS Point cluster
        for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
        {
            covariance_count = (*_it_msr)->vectorCount2;
 
            if (vAssocStnList_.at((*_it_msr)->station1).IsInvalid())
                return false; 
 
            if ((*_it_msr)->measType == 'X')
                if (vAssocStnList_.at((*_it_msr)->station2).IsInvalid())
                    return false;
            
            (*_it_msr) += 2;                    // skip y and z
            (*_it_msr) += covariance_count * 3; // skip covariances
 
            if (covariance_count > 0)
                (*_it_msr)++;
        }
        break;
    case 'D':   // Direction set
        for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
        {
            // Check first station
            if (cluster_msr == 0)
                if (vAssocStnList_.at((*_it_msr)->station1).IsInvalid())
                    return false;
            // Check all target directions
            if (vAssocStnList_.at((*_it_msr)->station2).IsInvalid())
                return false;
            
            if (cluster_msr+1 == cluster_count)
                break;
                
            (*_it_msr)++;
        }
        break;
    }
    return true;
}

References vAssocStnList_.

Referenced by PrintIgnoredAdjMeasurements().

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11897 of file dnaadjust.cpp.

{
    std::stringstream ss;
 
    // Since the stations connected by an ignored measurement may appear
    // in different blocks, it is essential to get the correct block 
    // number for each station.  For this, use v_blockStationsMapUnique_ which
    // is sorted on station id.
    std::sort(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end());
 
    switch ((*_it_msr)->measType)
    {
    case 'A':   // Horizontal angle
        UpdateIgnoredMeasurements_A(_it_msr, storeOriginalMeasurement);
        break;
    case 'B':   // Geodetic azimuth
        UpdateIgnoredMeasurements_B(_it_msr, storeOriginalMeasurement);
        break;
    case 'C':   // Chord dist
        UpdateIgnoredMeasurements_C(_it_msr, storeOriginalMeasurement);
        break;
    case 'D':   // Direction set
        UpdateIgnoredMeasurements_D(_it_msr, storeOriginalMeasurement);
        break;
    case 'E':   // Ellipsoid arc
        UpdateIgnoredMeasurements_E(_it_msr, storeOriginalMeasurement);
        break;
    case 'G':   // GPS Baseline
        UpdateIgnoredMeasurements_G(_it_msr, storeOriginalMeasurement);
        break;
    case 'H':   // Orthometric height
        UpdateIgnoredMeasurements_H(_it_msr, storeOriginalMeasurement);
        break;
    case 'I':   // Astronomic latitude
        UpdateIgnoredMeasurements_I(_it_msr, storeOriginalMeasurement);
        break;
    case 'J':   // Astronomic longitude
        UpdateIgnoredMeasurements_J(_it_msr, storeOriginalMeasurement);
        break;
    case 'K':   // Astronomic azimuth
        UpdateIgnoredMeasurements_K(_it_msr, storeOriginalMeasurement);
        break;
    case 'L':   // Level difference
        UpdateIgnoredMeasurements_L(_it_msr, storeOriginalMeasurement);
        break;
    case 'M':   // MSL arc
        UpdateIgnoredMeasurements_M(_it_msr, storeOriginalMeasurement);
        break;
    case 'P':   // Geodetic latitude
        UpdateIgnoredMeasurements_P(_it_msr, storeOriginalMeasurement);
        break;
    case 'Q':   // Geodetic longitude
        UpdateIgnoredMeasurements_Q(_it_msr, storeOriginalMeasurement);
        break;
    case 'R':   // Ellipsoidal height
        UpdateIgnoredMeasurements_R(_it_msr, storeOriginalMeasurement);
        break;
    case 'S':   // Slope distance
        UpdateIgnoredMeasurements_S(_it_msr, storeOriginalMeasurement);
        break;
    case 'V':   // Zenith distance
        UpdateIgnoredMeasurements_V(_it_msr, storeOriginalMeasurement);
        break;
    case 'X':   // GPS Baseline cluster
        UpdateIgnoredMeasurements_X(_it_msr, storeOriginalMeasurement);
        break;
    case 'Y':   // GPS Point cluster
        UpdateIgnoredMeasurements_Y(_it_msr, storeOriginalMeasurement);
        break;
    case 'Z':   // Vertical angle
        UpdateIgnoredMeasurements_Z(_it_msr, storeOriginalMeasurement);
        break;
    default:
        ss << "UpdateIgnoredMeasurements(): Unknown measurement type - '" <<
            (*_it_msr)->measType << "'." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
}

Referenced by PrintIgnoredAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_A()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_A	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 10745 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_pair_u32u32_uint32 it_stnmap_range;
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    it_stnmap_range = equal_range(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end(),
        (*_it_msr)->station1, CompareBlockStationMapUnique_Station<UINT32, u32u32_uint32_pair>());
    if (it_stnmap_range.first == it_stnmap_range.second)
    {
        //TRACE("%d not found\n", (*_it_msr)->station1);
        std::stringstream ss;
        ss << "UpdateIgnoredMeasurements(): Station " << (*_it_msr)->station1 <<
            " was not found in the station map." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    // Get the index of the station in the map
    _it_bsmu = it_stnmap_range.first;
 
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
    
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    it_stnmap_range = equal_range(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end(),
        (*_it_msr)->station2, CompareBlockStationMapUnique_Station<UINT32, u32u32_uint32_pair>());
    if (it_stnmap_range.first == it_stnmap_range.second)
    {
        //TRACE("%d not found\n", (*_it_msr)->station2);
        std::stringstream ss;
        ss << "UpdateIgnoredMeasurements(): Station " << (*_it_msr)->station1 <<
            " was not found in the station map." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
    // Get the index of the station in the map
    _it_bsmu = it_stnmap_range.first;
 
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
    
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 3
    it_stnmap_range = equal_range(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end(),
        (*_it_msr)->station3, CompareBlockStationMapUnique_Station<UINT32, u32u32_uint32_pair>());
    if (it_stnmap_range.first == it_stnmap_range.second)
    {
        //TRACE("%d not found\n", (*_it_msr)->station3);
        std::stringstream ss;
        ss << "UpdateIgnoredMeasurements(): Station " << (*_it_msr)->station3 <<
            " was not found in the station map." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    // Get the index of the station in the map
    _it_bsmu = it_stnmap_range.first;
 
    matrix_2d* estimatedStations_stn3(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn3(GetBlkMatrixElemStn3(_it_bsmu->second, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
 
    double direction12, direction13, local_12e, local_12n, local_13e, local_13n;
 
    // compute angle 1 -> 2 -> 3 from estimated coordinates
    (*_it_msr)->measAdj = (HorizontalAngle(
        estimatedStations_stn1->get(stn1, 0),       // X1
        estimatedStations_stn1->get(stn1 + 1, 0),       // Y1
        estimatedStations_stn1->get(stn1 + 2, 0),       // Z1
        estimatedStations_stn2->get(stn2, 0),       // X2
        estimatedStations_stn2->get(stn2 + 1, 0),       // Y2
        estimatedStations_stn2->get(stn2 + 2, 0),       // Z2
        estimatedStations_stn3->get(stn3, 0),       // X3
        estimatedStations_stn3->get(stn3 + 1, 0),       // Y3
        estimatedStations_stn3->get(stn3 + 2, 0),       // Z3
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        &direction12, &direction13,
        &local_12e, &local_12n, &local_13e, &local_13n));
 
    // deflections available?
    if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
    {
        it_vstn_t stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
        it_vstn_t stn3_it(bstBinaryRecords_.begin() + (*_it_msr)->station3);
        // Angles (observed or derived from directions) must be corrected for deflection 
        // of the vertical via "Laplace correction".  This correction requires zenith 
        // distance (zenith12, zenith13) and geodetic azimuth (direction12, direction13), 
        // both of which must be computed from coordinates.
        // Compute zenith distance 1 -> 2
        double zenith12(ZenithDistance<double>(
            estimatedStations_stn1->get(stn1, 0),           // X1
            estimatedStations_stn1->get(stn1 + 1, 0),           // Y1
            estimatedStations_stn1->get(stn1 + 2, 0),           // Z1
            estimatedStations_stn2->get(stn2, 0),           // X2
            estimatedStations_stn2->get(stn2 + 1, 0),           // Y2
            estimatedStations_stn2->get(stn2 + 2, 0),           // Z2
            stn1_it->currentLatitude,
            stn1_it->currentLongitude,
            stn2_it->currentLatitude,
            stn2_it->currentLongitude,
            (*_it_msr)->term3,                          // instrument height
            (*_it_msr)->term4));                        // target height
        // Compute zenith distance 1 -> 3
        double zenith13(ZenithDistance<double>(
            estimatedStations_stn1->get(stn1, 0),           // X1
            estimatedStations_stn1->get(stn1 + 1, 0),           // Y1
            estimatedStations_stn1->get(stn1 + 2, 0),           // Z1
            estimatedStations_stn3->get(stn3, 0),           // X2
            estimatedStations_stn3->get(stn3 + 1, 0),           // Y2
            estimatedStations_stn3->get(stn3 + 2, 0),           // Z2
            stn1_it->currentLatitude,
            stn1_it->currentLongitude,
            stn3_it->currentLatitude,
            stn3_it->currentLongitude,
            (*_it_msr)->term3,                          // instrument height
            (*_it_msr)->term4));                        // target height
 
        // Laplace correction 1 -> 2 -> 3
        (*_it_msr)->preAdjCorr = HzAngleDeflectionCorrection<double>(
            direction12,                                // geodetic azimuth 1 -> 2
            zenith12,                                   // zenith distance 1 -> 2
            direction13,                                // geodetic azimuth 1 -> 3
            zenith13,                                   // zenith distance 1 -> 3
            stn1_it->verticalDef,                       // deflection in prime vertical
            stn1_it->meridianDef);                      // deflection in prime meridian
    }
    else
        (*_it_msr)->preAdjCorr = 0.;
 
    // compute adjustment correction
    (*_it_msr)->measAdj += (*_it_msr)->preAdjCorr;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, E4_SEC_DEFLECTION(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), GetBlkMatrixElemStn3(), HorizontalAngle(), HzAngleDeflectionCorrection(), SignalExceptionAdjustment(), v_blockStationsMapUnique_, v_estimatedStations_, and ZenithDistance().

Referenced by UpdateIgnoredMeasurements(), and UpdateIgnoredMeasurements_D().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_B()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_B	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 10894 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // Compute the geodetic azimuth
    UpdateIgnoredMeasurements_BK(_it_msr);
 
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References UpdateIgnoredMeasurements_BK().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_BK()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_BK ( pit_vmsr_t _it_msr )

private

Definition at line 10907 of file dnaadjust.cpp.

{   
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
    
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station2;
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    double local_12e, local_12n;
 
    // compute bearing from estimated coordinates
    (*_it_msr)->measAdj = (Direction(
        estimatedStations_stn1->get(stn1, 0),       // X1
        estimatedStations_stn1->get(stn1 + 1, 0),   // Y1
        estimatedStations_stn1->get(stn1 + 2, 0),   // Z1
        estimatedStations_stn2->get(stn2, 0),       // X2
        estimatedStations_stn2->get(stn2 + 1, 0),   // Y2
        estimatedStations_stn2->get(stn2 + 2, 0),   // Z2
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        &local_12e, &local_12n));
}

References bstBinaryRecords_, Direction(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements_B(), and UpdateIgnoredMeasurements_K().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_C()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_C	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 10944 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // As a C measurement is a direct vector between two points in the cartesian frame,
    // there will be no pre adjustment correction
    (*_it_msr)->preAdjCorr = 0.;
 
    // Compute the chord distance
    UpdateIgnoredMeasurements_CEM(_it_msr);
 
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References UpdateIgnoredMeasurements_CEM().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_CEM()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_CEM ( pit_vmsr_t _it_msr )

private

Definition at line 10962 of file dnaadjust.cpp.

{   
 
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
    
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station2;
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    double dX, dY, dZ;
 
    // calculate chord distance
    (*_it_msr)->measAdj = (EllipsoidChordDistance<double>(
        estimatedStations_stn1->get(stn1, 0),
        estimatedStations_stn1->get(stn1 + 1, 0),
        estimatedStations_stn1->get(stn1 + 2, 0),
        estimatedStations_stn2->get(stn2, 0),
        estimatedStations_stn2->get(stn2 + 1, 0),
        estimatedStations_stn2->get(stn2 + 2, 0),
        stn1_it->currentLatitude,
        stn2_it->currentLatitude,
        stn1_it->currentHeight,
        stn2_it->currentHeight,
        &dX, &dY, &dZ,
        datum_.GetEllipsoidRef()));
}

References bstBinaryRecords_, datum_, EllipsoidChordDistance(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements_C(), UpdateIgnoredMeasurements_E(), and UpdateIgnoredMeasurements_M().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_D()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_D	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11003 of file dnaadjust.cpp.

{
    it_vmsr_t _it_msr_first(*_it_msr);
    UINT32 a, angle_count((*_it_msr)->vectorCount1 - 1);      // number of directions excluding the RO
    
    vmsr_t angleRec;
    angleRec.push_back(*(*_it_msr));
    it_vmsr_t it_angle(angleRec.begin());
 
    double previousDirection((*_it_msr)->term1);
    double previousVariance((*_it_msr)->term2);
 
    (*_it_msr)++;
 
    // set derived angle, variance and covariance to the binary records
    // term1 = measured direction
    // term2 = variance (direction)
    // term3 = instrument height (not used)
    // term4 = target height (not used)
    // scale1 = derived angle corrected for deflection of the vertical
    // scale2 = variance (angle)
    // scale3 = covariance (angle) - for the context of vmsr_t angleRec only, so as to 
    //          properly form the normals from covariances formed from directions SDs
    // preAdjMeas = original derived angle
 
    if (projectSettings_.g.verbose > 6)
        debug_file << "Reduced angles from raw directions: ";
 
    try
    {
        for (a=0; a<angle_count; ++a)
        {
            it_angle->station3 = (*_it_msr)->station2;
 
            if (storeOriginalMeasurement)
            {               
                // Derive the angle from two directions
                it_angle->term1 = (*_it_msr)->term1 - previousDirection;
                if (it_angle->term1 < 0)
                    it_angle->term1 += TWO_PI;
                if (it_angle->term1 > TWO_PI)
                    it_angle->term1 -= TWO_PI;
                // Derive the variance of the angle
                (*_it_msr)->scale2 = previousVariance + (*_it_msr)->term2;
            }
            else
                it_angle->preAdjMeas = (*_it_msr)->scale1;
            
            UpdateIgnoredMeasurements_A(&it_angle, storeOriginalMeasurement);
                        
            // apply correction for deflections in the vertical
            (*_it_msr)->scale1 = it_angle->preAdjMeas;
            // compute adjustment correction
            (*_it_msr)->measCorr = it_angle->measCorr;
            // Update correction for deflection of the vertical
            (*_it_msr)->preAdjCorr = it_angle->preAdjCorr;
 
            if (a + 1 == angle_count)
                break;
 
            if (storeOriginalMeasurement)
            {
                previousDirection = (*_it_msr)->term1;
                previousVariance = (*_it_msr)->term2;
            }
 
            // prepare for next angle
            angleRec.push_back(*(*_it_msr));
            it_angle = angleRec.end() - 1;
 
            (*_it_msr)++;
        }
 
    }
    catch (...) {
 
        // Print error message to adj file and throw exception
        std::stringstream ss;
        ss << "UpdateIgnoredMeasurements_D(): An error was encountered whilst" << std::endl <<
            "  calculating ignored measurement details" << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
    
}

References debug_file, projectSettings_, SignalExceptionAdjustment(), TWO_PI(), and UpdateIgnoredMeasurements_A().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_E()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_E	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11089 of file dnaadjust.cpp.

{   
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // Compute the chord distance
    UpdateIgnoredMeasurements_CEM(_it_msr);
 
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
    
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station2;
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    // Compute Ellipsoid arc from Ellipsoid chord
    double ellipsoid_arc = EllipsoidChordtoEllipsoidArc<double>(
        (*_it_msr)->measAdj,        // use Ellipsoid chord computed by UpdateIgnoredMeasurements_CEM
        estimatedStations_stn1->get(stn1, 0),
        estimatedStations_stn1->get(stn1 + 1, 0),
        estimatedStations_stn1->get(stn1 + 2, 0),
        estimatedStations_stn2->get(stn2, 0),
        estimatedStations_stn2->get(stn2 + 1, 0),
        estimatedStations_stn2->get(stn2 + 2, 0),
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        stn2_it->currentLatitude,
        datum_.GetEllipsoidRef());
 
    // compute correction from arc to chord
    (*_it_msr)->preAdjCorr = ellipsoid_arc - (*_it_msr)->measAdj;
    // update adjusted measurement
    (*_it_msr)->measAdj = ellipsoid_arc;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, datum_, EllipsoidChordtoEllipsoidArc(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), UpdateIgnoredMeasurements_CEM(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_G()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_G	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11140 of file dnaadjust.cpp.

{
    UpdateIgnoredMeasurements_GX(_it_msr, storeOriginalMeasurement);
}

References UpdateIgnoredMeasurements_GX().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_GX()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_GX	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11145 of file dnaadjust.cpp.

{
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station2;
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
 
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        // X element
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
    // update adjusted measurement
    (*_it_msr)->measAdj = (estimatedStations_stn2->get(stn2, 0) - estimatedStations_stn1->get(stn1, 0));
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
 
    // move to Y element
    (*_it_msr)++;
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
    // update adjusted measurement
    (*_it_msr)->measAdj = (estimatedStations_stn2->get(stn2+1, 0) - estimatedStations_stn1->get(stn1+1, 0));
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
 
    // move to Z element
    (*_it_msr)++;
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
    // update adjusted measurement
    (*_it_msr)->measAdj = (estimatedStations_stn2->get(stn2+2, 0) - estimatedStations_stn1->get(stn1+2, 0));
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements_G(), and UpdateIgnoredMeasurements_X().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_H()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_H	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11192 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // Compute the ellipsoid height
    UpdateIgnoredMeasurements_HR(_it_msr);
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
 
    // N value available?
    if (fabs(stn1_it->geoidSep) > PRECISION_1E4)
    {
        // get ellipsoid - geoid separation
        (*_it_msr)->preAdjCorr = stn1_it->geoidSep;
    }
    else
        (*_it_msr)->preAdjCorr = 0.;
 
    (*_it_msr)->measAdj -= (*_it_msr)->preAdjCorr;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, PRECISION_1E4(), and UpdateIgnoredMeasurements_HR().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_HR()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_HR ( pit_vmsr_t _it_msr )

private

Definition at line 11218 of file dnaadjust.cpp.

{
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
 
    // Zn is the z coordinate element of the point on the z-axis 
    // which intersects with the the normal at the given Latitude
    double nu1, Zn1;
 
    // compute the ellipsoid height height
    (*_it_msr)->measAdj = (EllipsoidHeight<double>(
        estimatedStations->get(stn1, 0),
        estimatedStations->get(stn1 + 1, 0),
        estimatedStations->get(stn1 + 2, 0),
        stn1_it->currentLatitude,
        &nu1, &Zn1,
        datum_.GetEllipsoidRef()));
}

References bstBinaryRecords_, datum_, EllipsoidHeight(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements_H(), and UpdateIgnoredMeasurements_R().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_I()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_I	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11247 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // calculate geodetic latitude
    UpdateIgnoredMeasurements_IP(_it_msr);
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
 
    // deflections available?
    if (fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
        // deflection in the prime meridian
        (*_it_msr)->preAdjCorr = stn1_it->meridianDef;                      
    else
        (*_it_msr)->preAdjCorr = 0.;
 
    // apply deflection correction
    (*_it_msr)->measAdj += (*_it_msr)->preAdjCorr;                      
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, E4_SEC_DEFLECTION(), and UpdateIgnoredMeasurements_IP().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_IP()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_IP ( pit_vmsr_t _it_msr )

private

Definition at line 11272 of file dnaadjust.cpp.

{
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
 
    // compute the geodetic latitude
    (*_it_msr)->measAdj = (CartToLat<double>(
        estimatedStations->get(stn1, 0),            // X1
        estimatedStations->get(stn1 + 1, 0),        // Y1
        estimatedStations->get(stn1 + 2, 0),        // Z1
        datum_.GetEllipsoidRef()));
}

References CartToLat(), datum_, dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements_I(), and UpdateIgnoredMeasurements_P().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_J()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_J	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11293 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // calculate geodetic longitude
    UpdateIgnoredMeasurements_JQ(_it_msr);
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
 
    // deflections available?
    if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION)
        // deflection in the prime vertical
        (*_it_msr)->preAdjCorr =
        stn1_it->verticalDef / cos(stn1_it->currentLatitude);       // sec(a) = 1/cos(a)
    else
        (*_it_msr)->preAdjCorr = 0.;
    
    // apply deflection correction
    (*_it_msr)->measAdj += (*_it_msr)->preAdjCorr;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
    
}

References bstBinaryRecords_, E4_SEC_DEFLECTION(), and UpdateIgnoredMeasurements_JQ().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_JQ()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_JQ ( pit_vmsr_t _it_msr )

private

Definition at line 11320 of file dnaadjust.cpp.

{
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
    
    double latitude, longitude, ellipsoidHeight;
 
    // compute the geodetic longitude
    CartToGeo<double>(
        estimatedStations->get(stn1, 0),            // X1
        estimatedStations->get(stn1 + 1, 0),        // Y1
        estimatedStations->get(stn1 + 2, 0),        // Z1
        &latitude,
        &longitude,
        &ellipsoidHeight,
        datum_.GetEllipsoidRef());
 
    (*_it_msr)->measAdj = longitude;
}

References CartToGeo(), datum_, dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements_J(), and UpdateIgnoredMeasurements_Q().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_K()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_K	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11347 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // Compute the geodetic azimuth
    UpdateIgnoredMeasurements_BK(_it_msr);
 
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
    
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station2;
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
    
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    // deflections available?
    if ((*_it_msr)->measType == 'K' &&                      // Astro
        (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || // deflections available?
            fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION))
    {
        // Astronomic azimuths must be corrected for deflection of the vertical via
        // "Laplace correction".  This correction requires zenith distance and geodetic 
        // azimuth (comp_msr), both of which must be computed from coordinates.
        // Compute zenith distance
        double zenith(ZenithDistance<double>(
            estimatedStations_stn1->get(stn1, 0),                   // X1
            estimatedStations_stn1->get(stn1 + 1, 0),               // Y1
            estimatedStations_stn1->get(stn1 + 2, 0),               // Z1
            estimatedStations_stn2->get(stn2, 0),                   // X2
            estimatedStations_stn2->get(stn2 + 1, 0),               // Y2
            estimatedStations_stn2->get(stn2 + 2, 0),               // Z2
            stn1_it->currentLatitude,
            stn1_it->currentLongitude,
            stn2_it->currentLatitude,
            stn2_it->currentLongitude,
            (*_it_msr)->term3,                                  // instrument height
            (*_it_msr)->term4));                                // target height
 
        // Compute pre adjustment correction
        (*_it_msr)->preAdjCorr = LaplaceCorrection<double>(        // Laplace correction
            (*_it_msr)->measAdj,                                // geodetic azimuth
            zenith,                                             // zenith distance
            stn1_it->verticalDef,                               // deflection in prime vertical
            stn1_it->meridianDef,                               // deflection in prime meridian
            stn1_it->currentLatitude);
    }
    else
        (*_it_msr)->preAdjCorr = 0.;
 
    // apply correction for deflections in the vertical
    (*_it_msr)->measAdj += (*_it_msr)->preAdjCorr;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, E4_SEC_DEFLECTION(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), LaplaceCorrection(), UpdateIgnoredMeasurements_BK(), v_blockStationsMapUnique_, v_estimatedStations_, and ZenithDistance().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_L()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_L	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11418 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
    
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station2;
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    // Zn is the z coordinate element of the point on the z-axis 
    // which intersects with the the normal at the given Latitude
    double h1, h2, nu1, nu2, Zn1, Zn2;
 
    // calculated diff height
    (*_it_msr)->measAdj = (EllipsoidHeightDifference<double>(
        estimatedStations_stn1->get(stn1, 0),
        estimatedStations_stn1->get(stn1 + 1, 0),
        estimatedStations_stn1->get(stn1 + 2, 0),
        estimatedStations_stn2->get(stn2, 0),
        estimatedStations_stn2->get(stn2 + 1, 0),
        estimatedStations_stn2->get(stn2 + 2, 0),
        stn1_it->currentLatitude,
        stn2_it->currentLatitude,
        &h1, &h2, &nu1, &nu2, &Zn1, &Zn2,
        datum_.GetEllipsoidRef()));
 
    // N value available?
    if (fabs(stn1_it->geoidSep) > PRECISION_1E4 ||
        fabs(stn2_it->geoidSep) > PRECISION_1E4)
        // Compute ellipsoid-geoid separation correction
        (*_it_msr)->preAdjCorr = stn2_it->geoidSep - stn1_it->geoidSep;
    else
        (*_it_msr)->preAdjCorr = 0.;
 
    // apply the ellipsoid-geoid separation correction
    (*_it_msr)->measAdj -= (*_it_msr)->preAdjCorr;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, datum_, EllipsoidHeightDifference(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), PRECISION_1E4(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_M()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_M	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11475 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
    
    // Compute the chord distance
    UpdateIgnoredMeasurements_CEM(_it_msr);
        
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    // Compute MSL arc from Ellipsoid chord
    double msl_arc = EllipsoidChordtoMSLArc<double>(
        (*_it_msr)->measAdj,            // use Ellipsoid chord computed by UpdateIgnoredMeasurements_CEM
        stn1_it->currentLatitude, stn2_it->currentLatitude,
        stn1_it->geoidSep, stn2_it->geoidSep,
        datum_.GetEllipsoidRef());
 
    // compute correction from arc to chord
    (*_it_msr)->preAdjCorr = msl_arc - (*_it_msr)->measAdj;
    // update adjusted measurement
    (*_it_msr)->measAdj = msl_arc;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, datum_, EllipsoidChordtoMSLArc(), and UpdateIgnoredMeasurements_CEM().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_P()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_P	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11503 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    UpdateIgnoredMeasurements_IP(_it_msr);
 
    // As a P measurement is the result of a direct conversion of cartesian coordinates,
    // there will be no pre adjustment correction
    (*_it_msr)->preAdjCorr = 0.;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References UpdateIgnoredMeasurements_IP().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_Q()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_Q	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11519 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    UpdateIgnoredMeasurements_JQ(_it_msr);
 
    // As a Q measurement is the result of a direct conversion of cartesian coordinates,
    // there will be no pre adjustment correction
    (*_it_msr)->preAdjCorr = 0.;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References UpdateIgnoredMeasurements_JQ().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_R()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_R	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11535 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    UpdateIgnoredMeasurements_HR(_it_msr);
 
    // As a R measurement is the result of a direct conversion of cartesian coordinates,
    // there will be no pre adjustment correction
    (*_it_msr)->preAdjCorr = 0.;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References UpdateIgnoredMeasurements_HR().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_S()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_S	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11551 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_pair_u32u32_uint32 it_stnmap_range;
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    it_stnmap_range = equal_range(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end(), 
        (*_it_msr)->station1, CompareBlockStationMapUnique_Station<UINT32, u32u32_uint32_pair>());
    if (it_stnmap_range.first == it_stnmap_range.second)
    {
        //TRACE("%d not found\n", (*_it_msr)->station1);
        std::stringstream ss;
        ss << "UpdateIgnoredMeasurements(): Station " << (*_it_msr)->station1  << 
            " was not found in the station map." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }   
 
    // Get the index of the station in the map
    _it_bsmu = it_stnmap_range.first;
 
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
    
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    it_stnmap_range = equal_range(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end(),
        (*_it_msr)->station2, CompareBlockStationMapUnique_Station<UINT32, u32u32_uint32_pair>());
    if (it_stnmap_range.first == it_stnmap_range.second)
    {
        //TRACE("%d not found\n", (*_it_msr)->station2);
        std::stringstream ss;
        ss << "UpdateIgnoredMeasurements(): Station " << (*_it_msr)->station2 <<
            " was not found in the station map." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
    
    // Get the index of the station in the map
    _it_bsmu = it_stnmap_range.first;
 
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
    
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
 
    // compute dX, dY, dZ for instrument height (ih) and target height (th)
    double dXih, dYih, dZih, dXth, dYth, dZth;
    CartesianElementsFromInstrumentHeight((*_it_msr)->term3,               // instrument height
        &dXih, &dYih, &dZih,
        stn1_it->currentLatitude,
        stn1_it->currentLongitude);
    CartesianElementsFromInstrumentHeight((*_it_msr)->term4,               // target height
        &dXth, &dYth, &dZth,
        stn1_it->currentLatitude,
        stn1_it->currentLongitude);
 
    // compute distance between instrument and target, taking into consideration
    // instrument height, target height, and vector between stations
    double dX(estimatedStations_stn2->get(stn2, 0)     - estimatedStations_stn1->get(stn1, 0) + dXth - dXih);
    double dY(estimatedStations_stn2->get(stn2 + 1, 0) - estimatedStations_stn1->get(stn1 + 1, 0) + dYth - dYih);
    double dZ(estimatedStations_stn2->get(stn2 + 2, 0) - estimatedStations_stn1->get(stn1 + 2, 0) + dZth - dZih);
 
    // calculated distance
    (*_it_msr)->measAdj = (magnitude(dX, dY, dZ));
    // As an S measurement is the result of a direct computation from cartesian coordinates,
    // there will be no pre adjustment correction
    (*_it_msr)->preAdjCorr = 0.;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, CartesianElementsFromInstrumentHeight(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), magnitude(), SignalExceptionAdjustment(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_V()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_V	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11630 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station2;
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    double local_12e, local_12n, local_12up;
 
    // compute zenith distance from estimated coordinates
    (*_it_msr)->measAdj = (ZenithDistance(
        estimatedStations_stn1->get(stn1, 0),                   // X1
        estimatedStations_stn1->get(stn1 + 1, 0),                   // Y1
        estimatedStations_stn1->get(stn1 + 2, 0),                   // Z1
        estimatedStations_stn2->get(stn2, 0),                   // X2
        estimatedStations_stn2->get(stn2 + 1, 0),                   // Y2
        estimatedStations_stn2->get(stn2 + 2, 0),                   // Z2
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        stn2_it->currentLatitude,
        stn2_it->currentLongitude,
        (*_it_msr)->term3,                                  // instrument height
        (*_it_msr)->term4,                                  // target height
        &local_12e,                                         // local_12e, ..12n, ..12up represent
        &local_12n,                                         // the geometric difference between
        &local_12up));                                      // station1 and station2
 
    // deflections available?
    if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
    {
        // Correct for deflections in the vertical
        // 1. compute bearing from estimated coordinates
        double azimuth(Direction(
            estimatedStations_stn1->get(stn1, 0),       // X1
            estimatedStations_stn1->get(stn1 + 1, 0),       // Y1
            estimatedStations_stn1->get(stn1 + 2, 0),       // Z1
            estimatedStations_stn2->get(stn2, 0),       // X2
            estimatedStations_stn2->get(stn2 + 1, 0),       // Y2
            estimatedStations_stn2->get(stn2 + 2, 0),       // Z2
            stn1_it->currentLatitude,
            stn1_it->currentLongitude));
 
        // 2. Compute correction
        (*_it_msr)->preAdjCorr = ZenithDeflectionCorrection<double>(      // Correction to vertical angle for deflection of vertical
            azimuth,                                                        // geodetic azimuth
            stn1_it->verticalDef,                                           // deflection in prime vertical
            stn1_it->meridianDef);                                          // deflection in prime meridian
    }
    else
        (*_it_msr)->preAdjCorr = 0.;
 
    // apply correction for deflections in the vertical
    (*_it_msr)->measAdj -= (*_it_msr)->preAdjCorr;
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, Direction(), E4_SEC_DEFLECTION(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), v_blockStationsMapUnique_, v_estimatedStations_, ZenithDeflectionCorrection(), and ZenithDistance().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_X()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_X	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11708 of file dnaadjust.cpp.

{
    UINT32 cluster_bsl, baseline_count((*_it_msr)->vectorCount1);
    UINT32 covariance_count;
 
    for (cluster_bsl = 0; cluster_bsl < baseline_count; ++cluster_bsl)  // number of baselines/points
    {
        UpdateIgnoredMeasurements_GX(_it_msr, storeOriginalMeasurement);
 
        covariance_count = (*_it_msr)->vectorCount2;
 
        // skip covariances until next point
        (*_it_msr) += covariance_count * 3;
 
        if (covariance_count > 0)
            (*_it_msr)++;
    }
}

References UpdateIgnoredMeasurements_GX().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_Y()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_Y	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11728 of file dnaadjust.cpp.

{
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1.  Since Y clusters are
    // correlated measurements which are never split, all stations will
    // be in the same block as station 1.
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations(&v_estimatedStations_.at(_it_bsmu->second));
 
    UINT32 stn1;
    UINT32 cluster_pnt, point_count((*_it_msr)->vectorCount1);
    UINT32 covariance_count;
    it_vstn_t stn1_it;
    double latitude, longitude, height, x, y, z;
 
    _COORD_TYPE_ coordType(CDnaStation::GetCoordTypeC((*_it_msr)->coordType));
 
    for (cluster_pnt = 0; cluster_pnt < point_count; ++cluster_pnt)
    {
        covariance_count = (*_it_msr)->vectorCount2;
 
        stn1_it = bstBinaryRecords_.begin() + (*_it_msr)->station1;
 
        stn1 = GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr);
 
        // Get latest cartesian coordinates
        x = estimatedStations->get(stn1, 0);
        y = estimatedStations->get(stn1 + 1, 0);
        z = estimatedStations->get(stn1 + 2, 0);
        
        // initialise measurement (on the first adjustment only!)
        if (storeOriginalMeasurement)
            (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
        // Convert to geographic coordinates?
        if (coordType == LLH_type_i)
        {
            CartToGeo<double>(x, y, z, &latitude, &longitude, &height, datum_.GetEllipsoidRef());
            (*_it_msr)->measAdj = latitude;
        }
        else
            (*_it_msr)->measAdj = x;
            
        // move to Y element
        (*_it_msr)++;
        // initialise measurement (on the first adjustment only!)
        if (storeOriginalMeasurement)
            (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
        
        if (coordType == LLH_type_i)
            (*_it_msr)->measAdj = longitude;
        else
            (*_it_msr)->measAdj = y;
 
        // move to Z element
        (*_it_msr)++;
        // initialise measurement (on the first adjustment only!)
        if (storeOriginalMeasurement)
            (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
            
        if (coordType == LLH_type_i)
        {
            // Reduce to ellipsoid height?
            if (fabs(stn1_it->geoidSep) > PRECISION_1E4)
            {
                (*_it_msr)->preAdjCorr = stn1_it->geoidSep;
                (*_it_msr)->term1 += (*_it_msr)->preAdjCorr;
            }
 
            (*_it_msr)->measAdj = height;
        }
        else
            (*_it_msr)->measAdj = z;
 
        covariance_count = (*_it_msr)->vectorCount2;
 
        // skip covariances until next point
        (*_it_msr) += covariance_count * 3;
 
        if (covariance_count > 0)
            (*_it_msr)++;
    }
}

References bstBinaryRecords_, CartToGeo(), datum_, dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), dynadjust::measurements::CDnaStation::GetCoordTypeC(), LLH_type_i, PRECISION_1E4(), v_blockStationsMapUnique_, and v_estimatedStations_.

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIgnoredMeasurements_Z()

void dynadjust::networkadjust::dna_adjust::UpdateIgnoredMeasurements_Z	(	pit_vmsr_t	_it_msr,
		bool	storeOriginalMeasurement )

private

Definition at line 11819 of file dnaadjust.cpp.

{
    // initialise measurement (on the first adjustment only!)
    if (storeOriginalMeasurement)
        (*_it_msr)->preAdjMeas = (*_it_msr)->term1;
 
    // Use v_blockStationsMapUnique_ to get the correct block for each 
    // station in the measurement
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 1
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station1;
    matrix_2d* estimatedStations_stn1(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn1(GetBlkMatrixElemStn1(_it_bsmu->second, _it_msr));
    
    // Get estimated station coordinates matrix and index of the 
    // station within the matrix for station 2
    _it_bsmu = v_blockStationsMapUnique_.begin() + (*_it_msr)->station2;
    matrix_2d* estimatedStations_stn2(&v_estimatedStations_.at(_it_bsmu->second));
    UINT32 stn2(GetBlkMatrixElemStn2(_it_bsmu->second, _it_msr));
 
    it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + (*_it_msr)->station1);
    it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + (*_it_msr)->station2);
 
    double local_12e, local_12n, local_12up;
 
    // compute vertical angle from estimated coordinates
    (*_it_msr)->measAdj = (VerticalAngle(
        estimatedStations_stn1->get(stn1, 0),                   // X1
        estimatedStations_stn1->get(stn1 + 1, 0),                   // Y1
        estimatedStations_stn1->get(stn1 + 2, 0),                   // Z1
        estimatedStations_stn2->get(stn2, 0),                   // X2
        estimatedStations_stn2->get(stn2 + 1, 0),                   // Y2
        estimatedStations_stn2->get(stn2 + 2, 0),                   // Z2
        stn1_it->currentLatitude,
        stn1_it->currentLongitude,
        stn2_it->currentLatitude,
        stn2_it->currentLongitude,
        (*_it_msr)->term3,                                  // instrument height
        (*_it_msr)->term4,                                  // target height
        &local_12e,                                         // local_12e, ..12n, ..12up represent
        &local_12n,                                         // the geometric difference between
        &local_12up));                                      // station1 and station2
 
    // deflections available?
    if (fabs(stn1_it->verticalDef) > E4_SEC_DEFLECTION || fabs(stn1_it->meridianDef) > E4_SEC_DEFLECTION)
    {
        // Correct for deflection of the vertical
        // 1. compute bearing from estimated coordinates
        double azimuth(Direction(
            estimatedStations_stn1->get(stn1, 0),       // X1
            estimatedStations_stn1->get(stn1 + 1, 0),       // Y1
            estimatedStations_stn1->get(stn1 + 2, 0),       // Z1
            estimatedStations_stn2->get(stn2, 0),       // X2
            estimatedStations_stn2->get(stn2 + 1, 0),       // Y2
            estimatedStations_stn2->get(stn2 + 2, 0),       // Z2
            stn1_it->currentLatitude,
            stn1_it->currentLongitude));
 
        // 2. Compute correction
        (*_it_msr)->preAdjCorr = ZenithDeflectionCorrection<double>(      // Correction to vertical angle for deflection of vertical
            azimuth,                                                        // geodetic azimuth
            stn1_it->verticalDef,                                           // deflection in prime vertical
            stn1_it->meridianDef);                                          // deflection in prime meridian
    }
    else
        (*_it_msr)->preAdjCorr = 0.;
 
    // apply deflection correction
    (*_it_msr)->measAdj += (*_it_msr)->preAdjCorr;                      
    // compute adjustment correction
    (*_it_msr)->measCorr = (*_it_msr)->measAdj - (*_it_msr)->preAdjMeas;
}

References bstBinaryRecords_, Direction(), E4_SEC_DEFLECTION(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), v_blockStationsMapUnique_, v_estimatedStations_, VerticalAngle(), and ZenithDeflectionCorrection().

Referenced by UpdateIgnoredMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadVarianceScaling()

void dynadjust::networkadjust::dna_adjust::LoadVarianceScaling	(	it_vmsr_t	_it_msr,
		double &	vScale,
		double &	pScale,
		double &	lScale,
		double &	hScale,
		bool &	scaleMatrix,
		bool &	scalePartial )

private

Definition at line 5459 of file dnaadjust.cpp.

{
    vScale = _it_msr->scale4;
    
    // trap vscale equal to very small numbers or zero
    if (vScale < minVal(PRECISION_1E5, projectSettings_.a.fixed_std_dev))        
        vScale = 1.0;
 
    // non zero matrix scalar?
    scaleMatrix = (fabs(vScale - 1.0) > PRECISION_1E5);    
    
    // partial matrix scalars
    pScale = _it_msr->scale1;
    lScale = _it_msr->scale2;
    hScale = _it_msr->scale3;
    
    // trap vscale equal to very small numbers or zero
    if (pScale < minVal(PRECISION_1E5, projectSettings_.a.fixed_std_dev))
        pScale = 1.0;
    if (lScale < minVal(PRECISION_1E5, projectSettings_.a.fixed_std_dev))
        lScale = 1.0;   
    if (hScale < minVal(PRECISION_1E5, projectSettings_.a.fixed_std_dev))
        hScale = 1.0;
 
    if (fabs(pScale - 1.0) > PRECISION_1E5 || fabs(lScale - 1.0) > PRECISION_1E5 || fabs(hScale - 1.0) > PRECISION_1E5)
        scalePartial = true;
    else
        scalePartial = false;
 
    if (scalePartial && scaleMatrix)
    {
        // partial matrix scalars
        pScale *= vScale;
        lScale *= vScale;
        hScale *= vScale;
    }
}

References minVal(), PRECISION_1E5(), and projectSettings_.

Referenced by LoadVarianceMatrix_G(), LoadVarianceMatrix_X(), and LoadVarianceMatrix_Y().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadVarianceMatrix_D()

void dynadjust::networkadjust::dna_adjust::LoadVarianceMatrix_D	(	it_vmsr_t	_it_msr,
		matrix_2d *	var_dirn,
		bool	buildnewMatrices )

private

Definition at line 5065 of file dnaadjust.cpp.

{
    // load the correlated angles variance matrix from the binary file
    if (bms_meta_.reduced || !buildnewMatrices)
    {
        try {
            // load as-is, assuming that an adjustment has been run
            // and the variances have been reduced (scaled)
            GetDirectionsVarianceMatrix(_it_msr, var_dirn);
            FormInverseVarianceMatrix(var_dirn, true);
            return;
        }
        catch (const std::runtime_error& e) {
 
            // Print error message to adj file and throw exception
            std::stringstream ss;
            PrintMsrVarianceMatrixException(_it_msr, e, ss, "LoadVarianceMatrix_D");
            SignalExceptionAdjustment(ss.str(), 0);
        }
    }
 
    // OK, create the correlated angles variance matrix from the binary 
    // file
 
    it_vmsr_t _it_msr_first(_it_msr);
    
    // angle, variance and covariance set in the binary records as follows:
    // term1 = direction
    // term2 = variance (direction)
    // term3 = instrument height (leave as-is)
    // term4 = target height (leave as-is)
    // scale1 = derived angle corrected for deflection of the vertical
    // scale2 = variance (angle)
    // scale3 = covariance (angle)
    // vectorCount2 = number of non-ignored directions
    // preAdjMeas = original derived angle
 
    UINT32 a, angle_count(_it_msr->vectorCount2 - 1);     // number of directions excluding the RO
    
    matrix_2d A(angle_count, _it_msr->vectorCount2);
    matrix_2d AV(angle_count, _it_msr->vectorCount2);
    
    var_dirn->redim(angle_count, angle_count);
    var_dirn->zero();
    
    double previousVariance(_it_msr->term2);
    UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
 
    if (projectSettings_.g.verbose > 5)
        debug_file << std::endl << "Std dev " << std::scientific << std::setprecision(16) << _it_msr->term2 << " (" << std::fixed << std::setprecision(2) << Seconds(sqrt(_it_msr->term2)) << " seconds)" << std::endl;
    
    _it_msr++;
 
    // propagate (uncorrelated) directions variances to angles variances
    try {
        for (a=0; a<angle_count; ++a)
        {
            // cater for ignored directions
            if (_it_msr->ignore)
            {
                while (skip < ignored)
                {
                    skip++;
                    _it_msr++;
                    if (!_it_msr->ignore)
                        break;
                }
            }
 
            // Fill design & variance matrices to propagate variances from directions to angles
            A.put(a, a, -1);
            A.put(a, a+1, 1);
            AV.put(a, a, previousVariance * -1);
            AV.put(a, a+1, _it_msr->term2);
 
            if (projectSettings_.g.verbose > 5)
                debug_file << "Std dev " << std::scientific << std::setprecision(16) << _it_msr->term2 << " (" << std::fixed << std::setprecision(2) << Seconds(sqrt(_it_msr->term2)) << " seconds)" << std::endl;
 
            if (a+1 == angle_count)
                break;
 
            previousVariance = _it_msr->term2;
            _it_msr++;
        }
 
        if (projectSettings_.g.verbose > 6)
        {
            debug_file << std::endl << "Directions variance matrix:" << std::endl;
            debug_file << "A " << A << std::endl;
            debug_file << "AV " << std::scientific << std::setprecision(16) << AV << std::endl;
        }
 
        // AVAT for correlated angles will not be a fully populated matrix, but a 
        // banded one whereby correlations exist only for angles adjacent to each other.  
        // So, propagate manually.
        UINT32 d;
        for (a=0; a<angle_count; ++a)
        {
            // variances
            for (d=0; d<2; ++d)
                var_dirn->elementadd(a, a, AV.get(a, a+d) * A.get(a, a+d));
            if (a+1 == angle_count)
                break;
            // covariances
            var_dirn->elementadd(a, a+1, AV.get(a, a+1) * A.get(a+1, a+1));
            var_dirn->elementadd(a+1, a, var_dirn->get(a, a+1));
        }
 
        // Now the variance matrix has been formed, set the variances and 
        // covariances to the binary file
        SetDirectionsVarianceMatrix(_it_msr_first, *var_dirn);
 
        if (projectSettings_.g.verbose > 5)
            debug_file << "V.dxyz " << std::scientific << std::setprecision(16) << std::setw(26) << *var_dirn;
        
        // Form inverse
        FormInverseVarianceMatrix(var_dirn);
    }
    catch (const std::runtime_error& e) {
 
        // Print error message to adj file and throw exception
        std::stringstream ss;
        PrintMsrVarianceMatrixException(_it_msr_first, e, ss, "LoadVarianceMatrix_D");
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    if (projectSettings_.g.verbose > 5)
        debug_file << "Inv V.dxyz " << std::scientific << std::setprecision(16) << std::setw(26) << *var_dirn;
    
}

References bms_meta_, debug_file, dynadjust::math::matrix_2d::elementadd(), FormInverseVarianceMatrix(), dynadjust::math::matrix_2d::get(), GetDirectionsVarianceMatrix(), PrintMsrVarianceMatrixException(), projectSettings_, dynadjust::math::matrix_2d::put(), dynadjust::math::matrix_2d::redim(), Seconds(), SetDirectionsVarianceMatrix(), SignalExceptionAdjustment(), and dynadjust::math::matrix_2d::zero().

Referenced by UpdateDesignNormalMeasMatrices_D().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadVarianceMatrix_G()

void dynadjust::networkadjust::dna_adjust::LoadVarianceMatrix_G	(	it_vmsr_t	_it_msr,
		matrix_2d *	var_cart )

private

Definition at line 5220 of file dnaadjust.cpp.

{
    if (FormInverseVarianceMatrixReduced(_it_msr, var_cart, "LoadVarianceMatrix_G"))
        return;
 
    // OK, load the GPS variance matrix from the binary 
    // file, scaling where necessary
    
    it_vmsr_t _it_msr_first(_it_msr);
    UINT32 v(0);
    
    // Determine scaling
    double vScale, pScale, lScale, hScale;
    bool scaleMatrix, scalePartial;
    LoadVarianceScaling(_it_msr, vScale, pScale, lScale, hScale,
        scaleMatrix, scalePartial);
 
    var_cart->redim(3, 3);
 
    // vScale is performed on the fly, assuming that all VCVs for single baselines
    // will always be in the cartesian reference frame
 
    var_cart->put(0, v, scaleMatrix ? _it_msr->term2 * vScale : _it_msr->term2); // XX
 
    _it_msr++;
    v++;
 
    var_cart->put(0, v, scaleMatrix ? _it_msr->term2 * vScale : _it_msr->term2); // YX
    var_cart->put(1, v, scaleMatrix ? _it_msr->term3 * vScale : _it_msr->term3); // YY
    
    _it_msr++;
    v++;
 
    var_cart->put(0, v, scaleMatrix ? _it_msr->term2 * vScale : _it_msr->term2);     // ZX
    var_cart->put(1, v, scaleMatrix ? _it_msr->term3 * vScale : _it_msr->term3);     // ZY
    var_cart->put(2, v, scaleMatrix ? _it_msr->term4 * vScale : _it_msr->term4);     // ZZ
    
    bool lowerisClear(true);
    if (scaleMatrix || scalePartial)
    {
        var_cart->filllower();
        lowerisClear = false;
    }
 
    try {
 
        // Scale variance matrix using phi, lambda and height scalars?
        if (scalePartial)
        {
            it_vstn_t_const stn1_it(bstBinaryRecords_.begin() + _it_msr->station1);
            it_vstn_t_const stn2_it(bstBinaryRecords_.begin() + _it_msr->station2);
 
            // Note - it makes little difference whether the start point, end point or mid point
            // is chosen to form the rotation matrix.  Tests on a 1987.6 Km baseline show
            // sub-millimetre difference in the propagated results!
            // So no need to average - just use the starting point
 
            ScaleGPSVCV<double>(*var_cart, var_cart,
                stn1_it->currentLatitude, stn1_it->currentLongitude, stn1_it->currentHeight,
                datum_.GetEllipsoidRef(), 
                pScale, lScale, hScale);
        }
 
        // Copy elements of scaled variance matrix to variances held in internal memory (_it_msr)
        // only if VCV has been scaled (by vScale, or by pScale+lScale+hScale).
        // This alleviates having to repeat any scaling for subsequent computations
        // involving variances (i.e. sigma zero, Pelzer's reliability, etc)
        if (scaleMatrix || scalePartial)
            SetGPSVarianceMatrix(_it_msr_first, *var_cart);
        
        if (projectSettings_.a.stage)
            return;
        
        // inverse
        FormInverseVarianceMatrix(var_cart, lowerisClear);
        
        if (boost::math::isnan(var_cart->get(0, 0)) || boost::math::isinf(var_cart->get(0, 0)))
        {
            std::stringstream ss;
            ss << "Invalid variance matrix:" << std::endl;
            ss << std::setprecision(6) << std::fixed << *var_cart;
            SignalExceptionAdjustment(ss.str(), 0);
        }
    }
    catch (const std::runtime_error& e) {
 
        // Print error message to adj file and throw exception
        std::stringstream ss;
        PrintMsrVarianceMatrixException(_it_msr_first, e, ss, "LoadVarianceMatrix_G");
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    if (projectSettings_.g.verbose > 5)
        debug_file << std::endl << "Inv V.dxyz " << std::fixed << std::setprecision(16) << std::setw(26) << var_cart;
    
}

References bstBinaryRecords_, datum_, debug_file, dynadjust::math::matrix_2d::filllower(), FormInverseVarianceMatrix(), FormInverseVarianceMatrixReduced(), dynadjust::math::matrix_2d::get(), LoadVarianceScaling(), PrintMsrVarianceMatrixException(), projectSettings_, dynadjust::math::matrix_2d::put(), dynadjust::math::matrix_2d::redim(), ScaleGPSVCV(), SetGPSVarianceMatrix(), and SignalExceptionAdjustment().

Referenced by UpdateDesignNormalMeasMatrices_G().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadVarianceMatrix_X()

void dynadjust::networkadjust::dna_adjust::LoadVarianceMatrix_X	(	it_vmsr_t	_it_msr,
		matrix_2d *	var_cart )

private

Definition at line 5318 of file dnaadjust.cpp.

{
    if (FormInverseVarianceMatrixReduced(_it_msr, var_cart, "LoadVarianceMatrix_X"))
        return;
 
    // OK, load the GPS variance matrix from the binary 
    // file, scaling where necessary
    
    it_vmsr_t _it_msr_first(_it_msr);
 
    UINT32 covr(0), covc(0);
    UINT32 cluster_bsl, baseline_count(_it_msr->vectorCount1);
    UINT32 cluster_cov, covariance_count;
    var_cart->redim(baseline_count * 3, baseline_count * 3);
 
    matrix_2d mpositions(baseline_count * 3, 1);
 
    it_vstn_t stn1_it;
    it_vstn_t stn2_it;
 
    // Determine scaling
    double vScale, pScale, lScale, hScale;
    bool scaleMatrix, scalePartial;
    LoadVarianceScaling(_it_msr, vScale, pScale, lScale, hScale,
        scaleMatrix, scalePartial);
 
    for (cluster_bsl=0; cluster_bsl<baseline_count; ++cluster_bsl)  // number of baselines/points
    {
        covr = cluster_bsl * 3;
        covariance_count = _it_msr->vectorCount2;
 
        stn1_it = bstBinaryRecords_.begin() + _it_msr->station1;
        stn2_it = bstBinaryRecords_.begin() + _it_msr->station2;
    
        if (scalePartial)
        {
            // Note - it makes little difference whether the start point, end point or mid point
            // is chosen to form the rotation matrix.  Tests on a 1987.6 Km baseline show
            // sub-millimetre difference in the propagated results!
            // So no need to average - just use the starting point
            mpositions.put(covr, 0, stn1_it->currentLatitude);
            mpositions.put(covr+1, 0, stn1_it->currentLongitude);
            mpositions.put(covr+2, 0, stn1_it->currentHeight);
        }
 
        // vScale is performed on the fly, assuming that all VCVs for single baselines
        // will always be in the cartesian reference frame
 
        var_cart->put(covr, covr, scaleMatrix ? _it_msr->term2 * vScale : _it_msr->term2);   // XX
        
        _it_msr++;
 
        var_cart->put(covr,   covr+1, scaleMatrix ? _it_msr->term2 * vScale : _it_msr->term2);   // YX
        var_cart->put(covr+1, covr+1, scaleMatrix ? _it_msr->term3 * vScale : _it_msr->term3);   // YY
        
        _it_msr++;
 
        var_cart->put(covr,   covr+2, scaleMatrix ? _it_msr->term2 * vScale : _it_msr->term2);   // ZX
        var_cart->put(covr+1, covr+2, scaleMatrix ? _it_msr->term3 * vScale : _it_msr->term3);   // ZY
        var_cart->put(covr+2, covr+2, scaleMatrix ? _it_msr->term4 * vScale : _it_msr->term4);   // ZZ
 
        if (covariance_count == 0)
            break;
 
        covc = cluster_bsl * 3 + 3;
 
        for (cluster_cov=0; cluster_cov<covariance_count; ++cluster_cov)    // number of baseline/point covariances
        {
            covr = cluster_bsl * 3;
            _it_msr++;      // X, lat
            var_cart->put(covr, covc, scaleMatrix ? _it_msr->term1 * vScale : _it_msr->term1);       // m11
            var_cart->put(covr, covc+1, scaleMatrix ? _it_msr->term2 * vScale : _it_msr->term2); // m12
            var_cart->put(covr, covc+2, scaleMatrix ? _it_msr->term3 * vScale : _it_msr->term3); // m13
 
            covr++;
            _it_msr++;      // Y, long
            var_cart->put(covr, covc, scaleMatrix ? _it_msr->term1 * vScale : _it_msr->term1);       // m21
            var_cart->put(covr, covc+1, scaleMatrix ? _it_msr->term2 * vScale : _it_msr->term2); // m22
            var_cart->put(covr, covc+2, scaleMatrix ? _it_msr->term3 * vScale : _it_msr->term3); // m23
 
            covr++;
            _it_msr++;      // Z, height
            var_cart->put(covr, covc, scaleMatrix ? _it_msr->term1 * vScale : _it_msr->term1);       // m31
            var_cart->put(covr, covc+1, scaleMatrix ? _it_msr->term2 * vScale : _it_msr->term2); // m32
            var_cart->put(covr, covc+2, scaleMatrix ? _it_msr->term3 * vScale : _it_msr->term3); // m33          
 
            covc+=3;
        }
 
        // next cluster measurement
        _it_msr++;
    }
    
    bool lowerisClear(true);
 
    try {
 
        if (scaleMatrix || scalePartial)
        {   
            if (scalePartial)
            {
                var_cart->filllower();
                lowerisClear = false;
                ScaleGPSVCV_Cluster<double>(*var_cart, var_cart, 
                    mpositions, 
                    datum_.GetEllipsoidRef(), 
                    pScale, lScale, hScale);
 
            }   // if (scalePartial)
 
            // Copy elements of scaled variance matrix to variances held in internal memory (_it_msr)
            // This alleviates having to repeat any scaling for subsequent computations
            // involving variances (i.e. sigma zero, Pelzer's reliability, etc)
            SetGPSVarianceMatrix<it_vmsr_t>(_it_msr_first, *var_cart);
 
        }   // if (scaleMatrix || scalePartial)
        // inverse
        FormInverseVarianceMatrix(var_cart, lowerisClear);
 
        if (boost::math::isnan(var_cart->get(0, 0)) || boost::math::isinf(var_cart->get(0, 0)))
        {
            std::stringstream ss;
            ss << "Invalid variance matrix:" << std::endl;
            ss << std::setprecision(6) << std::fixed << *var_cart;
            SignalExceptionAdjustment(ss.str(), 0);
        }
    }
    catch (const std::runtime_error& e) {
 
        // Print error message to adj file and throw exception
        std::stringstream ss;
        PrintMsrVarianceMatrixException(_it_msr_first, e, ss, "LoadVarianceMatrix_X", baseline_count);
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    if (projectSettings_.g.verbose > 5)
        debug_file << std::endl << "Inv V.dxyz " << std::fixed << std::setprecision(16) << std::setw(26) << var_cart;
    
}

References bstBinaryRecords_, datum_, debug_file, dynadjust::math::matrix_2d::filllower(), FormInverseVarianceMatrix(), FormInverseVarianceMatrixReduced(), dynadjust::math::matrix_2d::get(), LoadVarianceScaling(), PrintMsrVarianceMatrixException(), projectSettings_, dynadjust::math::matrix_2d::put(), dynadjust::math::matrix_2d::redim(), ScaleGPSVCV_Cluster(), SetGPSVarianceMatrix(), and SignalExceptionAdjustment().

Referenced by UpdateDesignNormalMeasMatrices_X().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadVarianceMatrix_Y()

void dynadjust::networkadjust::dna_adjust::LoadVarianceMatrix_Y	(	it_vmsr_t	_it_msr,
		matrix_2d *	var_cart,
		const _COORD_TYPE_	coordType )

private

Definition at line 5500 of file dnaadjust.cpp.

{
    if (FormInverseVarianceMatrixReduced(_it_msr, var_cart, "LoadVarianceMatrix_Y"))
        return;
 
    // OK, load the GPS variance matrix from the binary 
    // file, scaling where necessary
    
    it_vmsr_t _it_msr_first(_it_msr);
 
    //**********************************************************************
    // NOTE!!!
    //
    // Scaling needs careful consideration.  Three things are relevant
    // 1. Cluster may be in X,Y,Z or Lat,Long,Height
    // 2. Single v-scale may be supplied
    // 3. Phi, lambda and height scalars may be supplied
    //
    // if XYZ, scaling is as follows:
    //   if both p,l,h scalars and v-scale are supplied, then
    //      * rotate VCV to geographic,
    //      * apply scalars in single step (i.e. multiply v-scale and p,l,h scalars)
    //      * rotate VCV to cartesian
    //   
    //   if only v-scale supplied, then
    //      * scale VCV
    //
    // else if PLH, scaling is as follows:
    //   if p,l,h scalars are supplied then
    //      * apply scalars in single step (i.e. multiply v-scale and p,l,h scalars)
    //      * rotate VCV to cartesian
    //   if v-scale supplied then
    //      * scale VCV
    //
    // Hence, it makes no difference whether v-scale is performed
    // on a cartesian or geographic VCV.
    //
    //**********************************************************************    
    
    // Units for GPS point clusters are in:
    // - <Coords>LLH</Coords> -> radians^^2 and metres^2
    // - <Coords>XYZ</Coords> -> metres^2
    //
    // An example of LLH is as follows (from "uni_sqrmsr.xml")
    //
    // Worked example:  <SigmaXX>9.402E-09</SigmaXX>
    //  = 0.000000009402 (radians^2)
    //  = 0.000096963911 (radians)
    //  = 0.005555622855 (deg.ddddddd)
    //  = 0.002000024228 (deg.mmsssss)
    //  = 20.0           (seconds)
 
 
    UINT32 covr(0), covc(0);
    UINT32 cluster_pnt, point_count(_it_msr->vectorCount1);
    UINT32 cluster_cov, covariance_count;
    
    // Determine scaling
    double vScale, pScale, lScale, hScale;
    bool scaleMatrix, scalePartial;
    LoadVarianceScaling(_it_msr, vScale, pScale, lScale, hScale,
        scaleMatrix, scalePartial);
 
    var_cart->redim(point_count * 3, point_count * 3);     // performs zero on creation of new elements
    
    matrix_2d mpositions(point_count * 3, 1);
    it_vstn_t stn1_it;
 
    for (cluster_pnt=0; cluster_pnt<point_count; ++cluster_pnt)
    {
        covr = cluster_pnt * 3;
        covariance_count = _it_msr->vectorCount2;
 
        stn1_it = bstBinaryRecords_.begin() + _it_msr->station1;
 
        // store latitude, longitude and ellipsoid height
        if (scalePartial || coordType == LLH_type_i)
        {
            mpositions.put(covr, 0, stn1_it->currentLatitude);
            mpositions.put(covr+1, 0, stn1_it->currentLongitude);
            mpositions.put(covr+2, 0, stn1_it->currentHeight);
        }
 
        var_cart->put(covr, covr, _it_msr->term2);       // XX
        _it_msr++;
 
        var_cart->put(covr, covr+1, _it_msr->term2); // YX
        var_cart->put(covr+1, covr+1, _it_msr->term3);   // YY
        _it_msr++;  
        
        var_cart->put(covr,   covr+2, _it_msr->term2);   // ZX
        var_cart->put(covr+1, covr+2, _it_msr->term3);   // ZY
        var_cart->put(covr+2, covr+2, _it_msr->term4);   // ZZ
 
        if (covariance_count == 0)
            break;
 
        covc = cluster_pnt * 3 + 3;
 
        for (cluster_cov=0; cluster_cov<covariance_count; ++cluster_cov)    // number of baseline/point covariances
        {
            covr = cluster_pnt * 3;
            _it_msr++;      // X, lat
            var_cart->put(covr, covc, _it_msr->term1);       // m11
            var_cart->put(covr, covc+1, _it_msr->term2); // m12
            var_cart->put(covr, covc+2, _it_msr->term3); // m13
 
            covr++;
            _it_msr++;      // Y, long
            var_cart->put(covr, covc, _it_msr->term1);       // m11
            var_cart->put(covr, covc+1, _it_msr->term2); // m12
            var_cart->put(covr, covc+2, _it_msr->term3); // m13
 
            covr++;
            _it_msr++;      // Z, height
            var_cart->put(covr, covc, _it_msr->term1);       // m11
            var_cart->put(covr, covc+1, _it_msr->term2); // m12
            var_cart->put(covr, covc+2, _it_msr->term3); // m13          
 
            covc+=3;
        }
 
        _it_msr++;
    }
 
    bool lowerisClear(true);
    if (scaleMatrix || scalePartial || coordType == LLH_type_i)
    {
        var_cart->filllower();
        lowerisClear = false;
    }
 
    try {       
 
        // Scale variance matrix using phi, lambda and height scalars?
        if (scalePartial)
            // If v-scale has been supplied, partial scalars will have been 
            // multiplied by v-scale in LoadVarianceScaling.
            // ScaleGPSVCV_Cluster also converts var_cart to cartesian system
            ScaleGPSVCV_Cluster<double>(*var_cart, var_cart, 
                mpositions, 
                datum_.GetEllipsoidRef(),
                pScale, lScale, hScale, coordType);
 
        // Propagate variance matrix into cartesian reference frame?
        else if (coordType == LLH_type_i) 
            PropagateVariances_GeoCart_Cluster<double>(*var_cart, var_cart,
                mpositions, 
                datum_.GetEllipsoidRef(), 
                true);      // Geographic -> Cartesian
 
        if (scaleMatrix && !scalePartial)
            var_cart->scale(vScale);
 
        // Copy elements of scaled variance matrix to variances held in internal memory (_it_msr)
        // only if VCV has been scaled (by vScale, or by pScale+lScale+hScale) or if VCV was
        // in PLH reference frame.
        // This alleviates having to repeat any scaling for subsequent computations
        // involving variances (i.e. sigma zero, Pelzer's reliability, etc)
        if (scaleMatrix || scalePartial || coordType == LLH_type_i)
            SetGPSVarianceMatrix<it_vmsr_t>(_it_msr_first, *var_cart);
        
        // Perform inverse
        FormInverseVarianceMatrix(var_cart, lowerisClear);
 
        if (boost::math::isnan(var_cart->get(0, 0)) || boost::math::isinf(var_cart->get(0, 0)))
        {
            std::stringstream ss;
            ss << "Invalid variance matrix:" << std::endl;
            ss << std::setprecision(6) << std::fixed << *var_cart;
            SignalExceptionAdjustment(ss.str(), 0);
        }
    }
    catch (const std::runtime_error& e) {
 
        // Print error message to adj file and throw exception
        std::stringstream ss;
        PrintMsrVarianceMatrixException(_it_msr_first, e, ss, "LoadVarianceMatrix_Y", point_count);
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    if (projectSettings_.g.verbose > 5)
        debug_file << std::endl << "Inv V.dxyz " << std::fixed << std::setprecision(16) << std::setw(26) << var_cart;
    
}

References bstBinaryRecords_, datum_, debug_file, dynadjust::math::matrix_2d::filllower(), FormInverseVarianceMatrix(), FormInverseVarianceMatrixReduced(), dynadjust::math::matrix_2d::get(), LLH_type_i, LoadVarianceScaling(), PrintMsrVarianceMatrixException(), projectSettings_, PropagateVariances_GeoCart_Cluster(), dynadjust::math::matrix_2d::put(), dynadjust::math::matrix_2d::redim(), dynadjust::math::matrix_2d::scale(), ScaleGPSVCV_Cluster(), SetGPSVarianceMatrix(), and SignalExceptionAdjustment().

Referenced by UpdateDesignNormalMeasMatrices_Y().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintMsrVarianceMatrixException()

void dynadjust::networkadjust::dna_adjust::PrintMsrVarianceMatrixException	(	const it_vmsr_t &	_it_msr,
		const std::runtime_error &	e,
		std::stringstream &	ss,
		const std::string &	calling_function,
		const UINT32	msr_count = 0 )

private

Definition at line 4990 of file dnaadjust.cpp.

{
    it_vmsr_t _it_msr_temp(_it_msr);
 
    switch (_it_msr->measType)
    {
    case 'D':
        ss << calling_function << "(): Cannot compute the" << std::endl <<
            "  variance matrix for a round of " << msr_count << " directions commencing" << std::endl <<
            "  with stations " << bstBinaryRecords_.at(_it_msr->station1).stationName << " and " <<
            bstBinaryRecords_.at(_it_msr->station2).stationName << ":" << std::endl;
 
        ss << "    ..." << std::endl <<
            "    <Value>" << FormatDmsString(RadtoDms(_it_msr->term1), PRECISION_SEC_MSR, true, false) << "</Value>" << std::endl <<
            "    ..." << std::endl << std::endl;
        break;
    case 'G':
        ss << calling_function << "(): Cannot invert the" << std::endl <<
            "  variance matrix for a GPS baseline between stations " << 
            bstBinaryRecords_.at(_it_msr->station1).stationName << " and " <<
            bstBinaryRecords_.at(_it_msr->station2).stationName << ":" << std::endl;
 
        ss << "    ..." << std::endl <<
            "    <x>" << std::fixed << std::setprecision(PRECISION_MTR_MSR) << _it_msr_temp->term1 << "</x>" << std::endl;
        _it_msr_temp++;
        ss << "    <y>" << std::fixed << std::setprecision(PRECISION_MTR_MSR) << _it_msr_temp->term1 << "</y>" << std::endl;
        _it_msr_temp++;
        ss << "    <z>" << std::fixed << std::setprecision(PRECISION_MTR_MSR) << _it_msr_temp->term1 << "</z>" << std::endl <<
            "    ..." << std::endl << std::endl;
        break;
    case 'X':
        ss << calling_function << "(): Cannot invert the" << std::endl <<
            "  variance matrix for a " << msr_count << "-baseline GPS baseline cluster commencing" << std::endl <<
            "  with stations " << bstBinaryRecords_.at(_it_msr->station1).stationName << " and " <<
            bstBinaryRecords_.at(_it_msr->station2).stationName << ":" << std::endl;
 
        ss << "    ..." << std::endl <<
            "    <x>" << std::fixed << std::setprecision(PRECISION_MTR_MSR) << _it_msr_temp->term1 << "</x>" << std::endl;
        _it_msr_temp++;
        ss << "    <y>" << std::fixed << std::setprecision(PRECISION_MTR_MSR) << _it_msr_temp->term1 << "</y>" << std::endl;
        _it_msr_temp++;
        ss << "    <z>" << std::fixed << std::setprecision(PRECISION_MTR_MSR) << _it_msr_temp->term1 << "</z>" << std::endl <<
            "    ..." << std::endl << std::endl;
        break;
    case 'Y':
        ss << calling_function << "(): Cannot invert the" << std::endl <<
            "  variance matrix for a " << msr_count << "-station GPS point cluster commencing" << std::endl <<
            "  with station " << bstBinaryRecords_.at(_it_msr->station1).stationName << ":" << std::endl;
 
        ss << "    ..." << std::endl <<
            "    <x>" << std::fixed << std::setprecision(PRECISION_MTR_MSR) << _it_msr_temp->term1 << "</x>" << std::endl;
        _it_msr_temp++;
        ss << "    <y>" << std::fixed << std::setprecision(PRECISION_MTR_MSR) << _it_msr_temp->term1 << "</y>" << std::endl;
        _it_msr_temp++;
        ss << "    <z>" << std::fixed << std::setprecision(PRECISION_MTR_MSR) << _it_msr_temp->term1 << "</z>" << std::endl <<
            "    ..." << std::endl << std::endl;
        break;
    }
    
    ss <<
        "  Detailed description:   " << e.what() << std::endl <<
        "  Options: " << std::endl <<
        "  - Check the validity of the variance matrix and any relevant " << std::endl <<
        "    scalars and re-attempt the adjustment." << std::endl <<
        "  - If this fails, set the ignore flag in the measurement file and re-import " << std::endl <<
        "    the station and measurement files." << std::endl;
 
    adj_file << "  " << ss.str() << std::endl;
    adj_file.flush();
}

References adj_file, bstBinaryRecords_, FormatDmsString(), PRECISION_MTR_MSR, PRECISION_SEC_MSR, and RadtoDms().

Referenced by FormInverseVarianceMatrixReduced(), LoadVarianceMatrix_D(), LoadVarianceMatrix_G(), LoadVarianceMatrix_X(), and LoadVarianceMatrix_Y().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareStationandVarianceMatrices()

void dynadjust::networkadjust::dna_adjust::PrepareStationandVarianceMatrices ( const UINT32 & block )

private

Definition at line 887 of file dnaadjust.cpp.

{   
    // Is this a staged adjustment for which the matrix data is to be loaded from
    // existing stage files created from a previous run?    
    if (projectSettings_.a.stage && !projectSettings_.a.recreate_stage_files && bms_meta_.reduced)
    {
        // Staged adjustments only.
        // Load matrix data from existing .mtx stage files 
        // created from a previous run.
 
        // redimension the estimated stations matrix
        v_estimatedStations_.at(block).setsize(v_unknownsCount_.at(block), 1);
    
        // redimension the original stations
        v_originalStations_.at(block).setsize(v_unknownsCount_.at(block), 1);
    }
    else
    {
        // Simultaneous, phased (multithreaded and staged) adjustments
        // For staged adjustments, create new .mtx stage files
 
        // redimension the estimated stations matrix
        v_estimatedStations_.at(block).redim(v_unknownsCount_.at(block), 1);
    
        // redimension the original stations
        v_originalStations_.at(block).redim(v_unknownsCount_.at(block), 1);
    }
    
    // Populate matrices with coordinates and
    // for phased adjustment, add junction stations
    switch (projectSettings_.a.adjust_mode)
    {
    case SimultaneousMode:
        PopulateEstimatedStationMatrix(block, unknownParams_);
        break;  
    case Phased_Block_1Mode:
    case PhasedMode:
        
        UINT32 j(static_cast<UINT32>(v_JSL_.at(block).size() * 3));
 
        // Is this a staged adjustment for which the matrix data is to be loaded from
        // existing stage files created from a previous run?    
        if (projectSettings_.a.stage && !projectSettings_.a.recreate_stage_files && bms_meta_.reduced)
        {
            // Staged adjustments only.
            // Load matrix data from existing .mtx stage files 
            // created from a previous run.
 
            // resize rigorous coordinate estimate array
            v_rigorousStations_.at(block).setsize(v_unknownsCount_.at(block), 1);
        
            // resize rigorous variances
            v_rigorousVariances_.at(block).setsize(v_unknownsCount_.at(block), v_unknownsCount_.at(block));
 
            // resize junction variances
            v_junctionVariances_.at(block).setsize(j, j);
 
            // resize junction station coordinate estimate arrays
            if (!v_blockMeta_.at(block)._blockLast && !v_blockMeta_.at(block)._blockIsolated)
            {
                v_junctionVariancesFwd_.at(block).setsize(j, j);
                v_junctionEstimatesFwd_.at(block).setsize(j, 1);     
                v_junctionEstimatesRev_.at(block+1).setsize(j, 1);
            }
        }
        else
        {       
            // Phased (multithreaded and staged) adjustments
            // For staged adjustments, create new .mtx stage files
 
            // resize rigorous coordinate estimate array
            v_rigorousStations_.at(block).redim(v_unknownsCount_.at(block), 1);
        
            // resize rigorous variances
            v_rigorousVariances_.at(block).redim(v_unknownsCount_.at(block), v_unknownsCount_.at(block));
 
            // resize junction variances
            v_junctionVariances_.at(block).redim(j, j);
 
            // resize junction station coordinate estimate arrays
            if (!v_blockMeta_.at(block)._blockLast && !v_blockMeta_.at(block)._blockIsolated)
            {
                v_junctionVariancesFwd_.at(block).redim(j, j);
                v_junctionEstimatesFwd_.at(block).redim(j, 1);       
                v_junctionEstimatesRev_.at(block+1).redim(j, 1);
            }
        
            PopulateEstimatedStationMatrix(block, v_unknownParams_.at(block));
        }
        break;
    }
}

References bms_meta_, Phased_Block_1Mode, PhasedMode, PopulateEstimatedStationMatrix(), projectSettings_, SimultaneousMode, unknownParams_, v_blockMeta_, v_estimatedStations_, v_JSL_, v_junctionEstimatesFwd_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesFwd_, v_originalStations_, v_rigorousStations_, v_rigorousVariances_, v_unknownParams_, and v_unknownsCount_.

Referenced by PrepareAdjustmentBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareMappedRegions()

void dynadjust::networkadjust::dna_adjust::PrepareMappedRegions ( const UINT32 & block )

private

Definition at line 30 of file dnaadjust-stage.cpp.

{
    if (projectSettings_.a.adjust_mode == SimultaneousMode)
        return;
    if (projectSettings_.a.multi_thread)
        return;
 
    // Set memory map region offsets for all 
    // matrices associated with this block
    SetRegionOffsets(block);
 
    // Set memory mapped file regions
    // NOTE - previously created files must exist and match the 
    // dimensions of the current matrix sizes           
    try {
        PrepareMemoryMapRegions(block);
    }
    catch (boost::interprocess::interprocess_exception& e){
        std::stringstream ss;
        ss << "PrepareMappedRegions() terminated while creating memory map" << std::endl;
        ss << "  regions from .mtx stage files. Details:\n  " << e.what() << std::endl << std::endl;
        ss << "  Please ensure the .mtx stage files from a previous staged" << std::endl;
        ss << "  adjustment exist, or re-run the adjustment using the" << std::endl;
        ss << "  --" << RECREATE_STAGE_FILES << " option." << std::endl;
        adj_file << std::endl << "- Error: " << ss.str() << std::endl;
        throw boost::enable_current_exception(std::runtime_error(ss.str()));
    }
}

References adj_file, PrepareMemoryMapRegions(), projectSettings_, RECREATE_STAGE_FILES, SetRegionOffsets(), and SimultaneousMode.

Referenced by PrepareAdjustmentBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PopulateEstimatedStationMatrix()

void dynadjust::networkadjust::dna_adjust::PopulateEstimatedStationMatrix	(	const UINT32 &	block,
		UINT32 &	unknownParams )

private

Definition at line 818 of file dnaadjust.cpp.

{   
    // assign inner and junction station coordinates
    it_vUINT32_const _it_stn;
 
    double X, Y, Z;
    UINT32 j(0);
 
    // add inner and junction stations (all stations in phased mode are kept in v_parameterStationList_)
    for (_it_stn=v_parameterStationList_.at(block).begin();
        _it_stn!=v_parameterStationList_.at(block).end(); 
        ++_it_stn)
    {
        GeoToCart<double>(
            bstBinaryRecords_.at(*_it_stn).currentLatitude,
            bstBinaryRecords_.at(*_it_stn).currentLongitude,
            bstBinaryRecords_.at(*_it_stn).currentHeight,
            &X, &Y, &Z, datum_.GetEllipsoidRef());
 
        // add junction stations
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
        case PhasedMode:
            v_rigorousStations_.at(block).put(j, 0, X);
        }
        
        v_estimatedStations_.at(block).put(j, 0, X);
        v_originalStations_.at(block).put(j++, 0, X);
        
        // add junction stations
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
        case PhasedMode:
            v_rigorousStations_.at(block).put(j, 0, Y);  
        }
        
        v_estimatedStations_.at(block).put(j, 0, Y);
        v_originalStations_.at(block).put(j++, 0, Y);
        
        // add junction stations
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
        case PhasedMode:
            v_rigorousStations_.at(block).put(j, 0, Z);
        }
        
        v_estimatedStations_.at(block).put(j, 0, Z);
        v_originalStations_.at(block).put(j++, 0, Z);
        
 
        // assign appropriate variances for constraint stations
        if (bstBinaryRecords_.at((*_it_stn)).stationConst[0] == 'C')
            unknownParams--;
            
        if (bstBinaryRecords_.at((*_it_stn)).stationConst[1] == 'C')
            unknownParams--;
            
        if (bstBinaryRecords_.at((*_it_stn)).stationConst[2] == 'C')
            unknownParams--;
    }
 
    if (unknownParams_ == 0 && unknownsCount_ > 0)
        allStationsFixed_ = true;
}

References allStationsFixed_, bstBinaryRecords_, datum_, GeoToCart(), Phased_Block_1Mode, PhasedMode, projectSettings_, unknownParams_, unknownsCount_, v_estimatedStations_, v_originalStations_, v_parameterStationList_, and v_rigorousStations_.

Referenced by PrepareStationandVarianceMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CarryStnEstimatesandVariancesForward()

void dynadjust::networkadjust::dna_adjust::CarryStnEstimatesandVariancesForward	(	const UINT32 &	thisBlock,
		const UINT32 &	nextBlock )

private

Definition at line 1147 of file dnaadjust.cpp.

{
    UINT32 jsl, jsl_cov;
    UINT32 jslvar, jslcovar;
    UINT32 est(0);
 
    it_vUINT32 _it_jsl(v_JSL_.at(thisBlock).begin()), _it_jsl_cov;
 
    // 1. Copy full covariance matrix and coordinate estimates of junctions to temporary
    for (_it_jsl=v_JSL_.at(thisBlock).begin(); _it_jsl!=v_JSL_.at(thisBlock).end(); ++_it_jsl)
    {
        // get index of this JSL
        jslvar = static_cast<UINT32>(std::distance(v_JSL_.at(thisBlock).begin(), _it_jsl) * 3);
        jsl = v_blockStationsMap_.at(thisBlock)[*_it_jsl] * 3;
        
        // copy variance elements for this JSL
        v_junctionVariances_.at(thisBlock).copyelements(jslvar, jslvar, 
            v_normals_.at(thisBlock), jsl, jsl, 3, 3);
        
        // copy junction estimates
        v_junctionEstimatesFwd_.at(thisBlock).copyelements(est, 0, 
            v_estimatedStations_.at(thisBlock), jsl, 0, 3, 1); 
 
        est += 3;
 
        // copy covariance elements for this JSL
        for (_it_jsl_cov=_it_jsl; _it_jsl_cov!=v_JSL_.at(thisBlock).end(); ++_it_jsl_cov)
        {
            // don't re-copy variances
            if (*_it_jsl_cov == *_it_jsl)
                continue;
 
            jslcovar = static_cast<UINT32>(std::distance(v_JSL_.at(thisBlock).begin(), _it_jsl_cov) * 3);
            jsl_cov = v_blockStationsMap_.at(thisBlock)[*_it_jsl_cov] * 3;
            v_junctionVariances_.at(thisBlock).copyelements(jslvar, jslcovar, 
                v_normals_.at(thisBlock), jsl, jsl_cov, 3, 3);
            v_junctionVariances_.at(thisBlock).copyelements(jslcovar, jslvar, 
                v_normals_.at(thisBlock), jsl_cov, jsl, 3, 3);
        }
    }
 
    if (projectSettings_.g.verbose > 5)
    {
        debug_file << "Variance matrix of junction station(s) ";
        for (_it_jsl=v_JSL_.at(thisBlock).begin(); _it_jsl!=v_JSL_.at(thisBlock).end(); ++_it_jsl)
            debug_file << bstBinaryRecords_.at(*_it_jsl).stationName << " ";
        debug_file << "carried forward: " << std::scientific << std::setprecision(16) << v_junctionVariances_.at(thisBlock);
    }   
 
    // 2. Perform inverse
    FormInverseVarianceMatrix(&(v_junctionVariances_.at(thisBlock)));
 
    // 3. Copy junction station variances for use in reverse combination adjustment
    v_junctionVariancesFwd_.at(thisBlock) = v_junctionVariances_.at(thisBlock);
 
    // 4. Grow msr-comp and AtVinv matrices for next block to include junction stations as measurements
    UINT32 pseudoMsrCount(static_cast<UINT32>(v_JSL_.at(thisBlock).size()));
    UINT32 pseudoMsrElemCount(pseudoMsrCount * 3);
    UINT32 paramCount(0), paramCount2, msrCountNext(v_measurementParams_.at(nextBlock));
    
    // grow matrices to accommodate JSL measurements
    v_measMinusComp_.at(nextBlock).grow(pseudoMsrElemCount, 0);
    v_AtVinv_.at(nextBlock).grow(0, pseudoMsrElemCount);
    
    // zero elements used in a prior iteration
    v_AtVinv_.at(nextBlock).zero(0, msrCountNext, v_AtVinv_.at(nextBlock).rows(), pseudoMsrElemCount);
    
    // 5. Add the temporary variance matrix to the normals of the next block, and form the 
    // msr-comp elements
    for (_it_jsl=v_JSL_.at(thisBlock).begin(); 
        _it_jsl!=v_JSL_.at(thisBlock).end(); 
        ++_it_jsl, paramCount+=3)
    {
        // get index of this JSL in the next block
        jsl = v_blockStationsMap_.at(nextBlock)[*_it_jsl] * 3;       // next block
        jslvar = static_cast<UINT32>(std::distance(v_JSL_.at(thisBlock).begin(), _it_jsl) * 3);
 
        // add variance elements for this JSL to normals of the next block
        v_normals_.at(nextBlock).blockadd(jsl, jsl,
            v_junctionVariances_.at(thisBlock), jslvar, jslvar, 3, 3);
 
        // copy variances elements for this JSL to v_AtVinv_ of the next block
        v_AtVinv_.at(nextBlock).copyelements(jsl, v_measurementParams_.at(nextBlock) + paramCount,
            v_junctionVariances_.at(thisBlock), jslvar, jslvar, 3, 3);
 
        // msr-comp elements
        // Measured-computed for junction stations carried forward (from thisBlock-1)
        // add station X measurement
        v_measMinusComp_.at(nextBlock).put(msrCountNext++, 0, 
            (v_junctionEstimatesFwd_.at(thisBlock).get(jslvar, 0) -
            v_estimatedStations_.at(nextBlock).get(jsl, 0)));           // X (meas - computed)
        
        // add station Y measurement
        v_measMinusComp_.at(nextBlock).put(msrCountNext++, 0, 
            (v_junctionEstimatesFwd_.at(thisBlock).get(jslvar+1, 0) -
            v_estimatedStations_.at(nextBlock).get(jsl+1, 0)));     // Y (meas - computed)
        
        // add station Z measurement
        v_measMinusComp_.at(nextBlock).put(msrCountNext++, 0, 
            (v_junctionEstimatesFwd_.at(thisBlock).get(jslvar+2, 0) -
            v_estimatedStations_.at(nextBlock).get(jsl+2, 0)));     // Z (meas - computed)
 
        paramCount2 = 0;
 
        // get index of all covariances for this JSL in the next block
        for (_it_jsl_cov=_it_jsl; 
            _it_jsl_cov!=v_JSL_.at(thisBlock).end();
            ++_it_jsl_cov, paramCount2+=3)
        {
            // don't re-copy variances
            if (*_it_jsl_cov == *_it_jsl)
                continue;
 
            jslcovar = static_cast<UINT32>(std::distance(v_JSL_.at(thisBlock).begin(), _it_jsl_cov) * 3);
            jsl_cov = v_blockStationsMap_.at(nextBlock)[*_it_jsl_cov] * 3;       // next block
 
            // copy covariance elements for this JSL to normals of the next block
            v_normals_.at(nextBlock).blockadd(jsl, jsl_cov,
                v_junctionVariances_.at(thisBlock), jslvar, jslcovar, 3, 3);
            v_normals_.at(nextBlock).blockadd(jsl_cov, jsl,
                v_junctionVariances_.at(thisBlock), jslcovar, jslvar, 3, 3);
 
            // copy covariance elements for this JSL to v_AtVinv_ of the next block
            v_AtVinv_.at(nextBlock).copyelements(jsl_cov, v_measurementParams_.at(nextBlock) + paramCount, 
                v_junctionVariances_.at(thisBlock), jslcovar, jslvar, 3, 3);
 
            v_AtVinv_.at(nextBlock).copyelements(jsl, v_measurementParams_.at(nextBlock) + paramCount + paramCount2, 
                v_junctionVariances_.at(thisBlock), jslvar, jslcovar, 3, 3);
        }
    }
}

References bstBinaryRecords_, debug_file, FormInverseVarianceMatrix(), projectSettings_, v_AtVinv_, v_blockStationsMap_, v_estimatedStations_, v_JSL_, v_junctionEstimatesFwd_, v_junctionVariances_, v_junctionVariancesFwd_, v_measMinusComp_, v_measurementParams_, and v_normals_.

Referenced by CarryForwardJunctions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CarryStnEstimatesandVariancesReverse()

void dynadjust::networkadjust::dna_adjust::CarryStnEstimatesandVariancesReverse	(	const UINT32 &	nextBlock,
		const UINT32 &	thisBlock,
		bool	MT_ReverseOrCombine )

private

Definition at line 1282 of file dnaadjust.cpp.

{
    UINT32 jsl_var_order_this, jsl_var_order_next, jsl_covar_order_this, jsl_covar_order_next;
    UINT32 jsl_var_next, jsl_covar_next;
    UINT32 est(0);
 
    matrix_2d* junctionVariances(&v_junctionVariances_.at(nextBlock));
    matrix_2d* aposterioriVariances(&v_normals_.at(thisBlock));
    matrix_2d* estimatedStationsThis(&v_estimatedStations_.at(thisBlock));
    matrix_2d* estimatedStationsNext(&v_estimatedStations_.at(nextBlock));
    matrix_2d* normals(&v_normals_.at(nextBlock));
    matrix_2d* measMinusCompNext(&v_measMinusComp_.at(nextBlock));
    matrix_2d* AtVinvNext(&v_AtVinv_.at(nextBlock));
 
    if (MT_ReverseOrCombine)
    {
        junctionVariances = &v_junctionVariancesR_.at(nextBlock);
        aposterioriVariances = &v_normalsR_.at(thisBlock);
        estimatedStationsThis = &v_estimatedStationsR_.at(thisBlock);
        estimatedStationsNext = &v_estimatedStationsR_.at(nextBlock);
        normals = &v_normalsR_.at(nextBlock);
        measMinusCompNext = &v_measMinusCompR_.at(nextBlock);
        AtVinvNext = &v_AtVinvR_.at(nextBlock);
    }
 
    it_vUINT32 _it_jsl(v_JSL_.at(nextBlock).begin()), _it_jsl_cov;
 
    // 1. Copy full covariance matrix and coordinate estimates of junctions to temporary
    for (_it_jsl=v_JSL_.at(nextBlock).begin(); _it_jsl!=v_JSL_.at(nextBlock).end(); ++_it_jsl)
    {
        // get index of this JSL
        jsl_var_next = static_cast<UINT32>(std::distance(v_JSL_.at(nextBlock).begin(), _it_jsl) * 3);
        jsl_var_order_this = v_blockStationsMap_.at(thisBlock)[*_it_jsl] * 3;
        
        // copy junction variance elements
        junctionVariances->copyelements(jsl_var_next, jsl_var_next, 
            aposterioriVariances, jsl_var_order_this, jsl_var_order_this, 3, 3);
        
        // copy junction estimates
        v_junctionEstimatesRev_.at(thisBlock).copyelements(est, 0, 
            estimatedStationsThis, jsl_var_order_this, 0, 3, 1); 
 
        est += 3;
 
        // copy upper covariances for this JSL in the next block
        for (_it_jsl_cov=_it_jsl; _it_jsl_cov!=v_JSL_.at(nextBlock).end(); ++_it_jsl_cov)
        {
            // don't re-copy variances
            if (*_it_jsl_cov == *_it_jsl)
                continue;
 
            jsl_covar_next = static_cast<UINT32>(std::distance(v_JSL_.at(nextBlock).begin(), _it_jsl_cov) * 3);
            jsl_covar_order_this = v_blockStationsMap_.at(thisBlock)[*_it_jsl_cov] * 3;
            junctionVariances->copyelements(jsl_var_next, jsl_covar_next, 
                aposterioriVariances, jsl_var_order_this, jsl_covar_order_this, 3, 3);
            junctionVariances->copyelements(jsl_covar_next, jsl_var_next, 
                aposterioriVariances, jsl_covar_order_this, jsl_var_order_this, 3, 3);
        }
    }
 
    if (projectSettings_.g.verbose > 5)
    {
        debug_file << "Variance matrix of junction station(s) ";
        for (_it_jsl=v_JSL_.at(nextBlock).begin(); _it_jsl!=v_JSL_.at(nextBlock).end(); ++_it_jsl)
            debug_file << bstBinaryRecords_.at(*_it_jsl).stationName << " ";
        debug_file << "carried reverse: " << std::scientific << std::setprecision(16) << v_junctionVariances_.at(thisBlock);
    }   
 
    // 2. Perform inverse
    FormInverseVarianceMatrix(junctionVariances);
 
    // 3. Grow msr-comp and AtVinv matrices for next block to include junction stations as measurements
    UINT32 pseudoMsrCount(static_cast<UINT32>(v_JSL_.at(nextBlock).size()));
    UINT32 pseudoMsrElemCount(pseudoMsrCount * 3);
    UINT32 paramCount(0), paramCount2, msrCountNext(v_measurementParams_.at(nextBlock));
    
    // grow matrices to accommodate JSL measurements
    measMinusCompNext->grow(pseudoMsrElemCount, 0);
    AtVinvNext->grow(0, pseudoMsrElemCount);
    
    // zero elements used in the forward pass
    AtVinvNext->zero(0, msrCountNext, AtVinvNext->rows(), pseudoMsrElemCount);
    
    // 4. Add the temporary variance matrix to the normals of the next block, and form the 
    // msr-comp elements
    for (_it_jsl=v_JSL_.at(nextBlock).begin(); 
        _it_jsl!=v_JSL_.at(nextBlock).end(); 
        ++_it_jsl, paramCount+=3)
    {
        // get index of this JSL in the next block
        jsl_var_next = static_cast<UINT32>(std::distance(v_JSL_.at(nextBlock).begin(), _it_jsl) * 3);
        jsl_var_order_this = v_blockStationsMap_.at(thisBlock)[*_it_jsl] * 3;        // previous block
        jsl_var_order_next = v_blockStationsMap_.at(nextBlock)[*_it_jsl] * 3;
 
        // add variance elements for this JSL to normals of the next block
        normals->blockadd(jsl_var_order_next, jsl_var_order_next,
            *junctionVariances, jsl_var_next, jsl_var_next, 3, 3);
 
        // copy variances elements for this JSL to v_AtVinv_ of the next block
        AtVinvNext->copyelements(jsl_var_order_next, v_measurementParams_.at(nextBlock) + paramCount,
            junctionVariances, jsl_var_next, jsl_var_next, 3, 3);
 
        // msr-comp elements
        // Measured-computed for junction stations carried forward (from thisBlock-1)
        // add station X measurement
        measMinusCompNext->put(msrCountNext++, 0, 
            (v_junctionEstimatesRev_.at(thisBlock).get(jsl_var_next, 0) -
            estimatedStationsNext->get(jsl_var_order_next, 0)));            // X (meas - computed)
        
        // add station Y measurement
        measMinusCompNext->put(msrCountNext++, 0, 
            (v_junctionEstimatesRev_.at(thisBlock).get(jsl_var_next+1, 0) -
            estimatedStationsNext->get(jsl_var_order_next+1, 0)));      // Y (meas - computed)
        
        // add station Z measurement
        measMinusCompNext->put(msrCountNext++, 0, 
            (v_junctionEstimatesRev_.at(thisBlock).get(jsl_var_next+2, 0) -
            estimatedStationsNext->get(jsl_var_order_next+2, 0)));      // Z (meas - computed)
 
        paramCount2 = 0;
 
        // get index of all covariances for this JSL in the next block
        for (_it_jsl_cov=_it_jsl; 
            _it_jsl_cov!=v_JSL_.at(nextBlock).end();
            ++_it_jsl_cov, paramCount2+=3)
        {
            // don't re-copy variances
            if (*_it_jsl_cov == *_it_jsl)
                continue;
 
            jsl_covar_next = static_cast<UINT32>(std::distance(v_JSL_.at(nextBlock).begin(), _it_jsl_cov) * 3);
            jsl_covar_order_next = v_blockStationsMap_.at(nextBlock)[*_it_jsl_cov] * 3;
 
            // add covariance elements for this JSL to normals of the next block
            normals->blockadd(jsl_covar_order_next, jsl_var_order_next, 
                *junctionVariances, jsl_covar_next, jsl_var_next, 3, 3);
 
            normals->blockadd(jsl_var_order_next, jsl_covar_order_next,  
                *junctionVariances, jsl_var_next, jsl_covar_next, 3, 3);
 
            // copy covariance elements for this JSL to v_AtVinv_ of the next block
            AtVinvNext->copyelements(jsl_covar_order_next, v_measurementParams_.at(nextBlock) + paramCount,
                junctionVariances, jsl_covar_next, jsl_var_next, 3, 3);
 
            AtVinvNext->copyelements(jsl_var_order_next, v_measurementParams_.at(nextBlock) + paramCount + paramCount2,
                junctionVariances, jsl_var_next, jsl_covar_next, 3, 3);
        }
    }
}

References dynadjust::math::matrix_2d::blockadd(), bstBinaryRecords_, dynadjust::math::matrix_2d::copyelements(), debug_file, FormInverseVarianceMatrix(), dynadjust::math::matrix_2d::get(), dynadjust::math::matrix_2d::grow(), projectSettings_, dynadjust::math::matrix_2d::put(), dynadjust::math::matrix_2d::rows(), v_AtVinv_, v_AtVinvR_, v_blockStationsMap_, v_estimatedStations_, v_estimatedStationsR_, v_JSL_, v_junctionEstimatesRev_, v_junctionVariances_, v_junctionVariancesR_, v_measMinusComp_, v_measMinusCompR_, v_measurementParams_, v_normals_, v_normalsR_, and dynadjust::math::matrix_2d::zero().

Referenced by CarryReverseJunctions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CarryStnEstimatesandVariancesCombine()

void dynadjust::networkadjust::dna_adjust::CarryStnEstimatesandVariancesCombine	(	const UINT32 &	nextBlock,
		const UINT32 &	thisBlock,
		UINT32 &	pseudomsrJSLCount,
		bool	MT_ReverseOrCombine )

private

Definition at line 4147 of file dnaadjust.cpp.

{
    UINT32 pseudomsrJSLBegin(v_measurementParams_.at(thisBlock));
 
    //   intermediate                                   last
    //   _____________                              _____________
    //  |             |                            |             |
    //  | msr-comp    |                            | msr-comp    |
    //  |_____________|                            |_____________|  /__ pseudomsrJSLBegin
    //  |             |                            |             |  
    //  |  jrev-comp  |                            |  jfwd-comp  |
    //  |_____________|  /__ pseudomsrJSLBegin     |_____________|
    //  |             |  
    //  |  jfwd-comp  |
    //  |_____________|
 
    if (!v_blockMeta_.at(thisBlock)._blockLast)
        // PrepareAdjustmentCombine will have already weeded out
        // irrelevant blocks by testing _blockIsolated and _blockFirst 
        // So, add sufficient elements for junction station elements from
        // reverse pass.
        pseudomsrJSLBegin += static_cast<UINT32>(v_JSL_.at(thisBlock).size() * 3);  // junctions from reverse
 
    UINT32 pseudoMsrCount(static_cast<UINT32>(v_JSL_.at(nextBlock).size()));          // junctions from forward
    UINT32 pseudoMsrElemCount(pseudoMsrCount * 3);
 
    matrix_2d* AtVinv(&v_AtVinv_.at(thisBlock));
    matrix_2d* normals(&v_normals_.at(thisBlock));
    matrix_2d* measMinusComp(&v_measMinusComp_.at(thisBlock));
    matrix_2d* estimatedStations(&v_estimatedStations_.at(thisBlock));
 
    if (MT_ReverseOrCombine)
    {
        // restore backup copy of normals
        v_normalsR_.at(thisBlock) = v_normalsRC_.at(thisBlock);
        normals = &v_normalsR_.at(thisBlock);
    
        AtVinv = &v_AtVinvR_.at(thisBlock);
        measMinusComp = &v_measMinusCompR_.at(thisBlock);
        estimatedStations = &v_estimatedStationsR_.at(thisBlock);
    }
    else
    {
 
        // restore normals for single thread mode
        // v_normalsR_.at(thisBlock) is the set of normals with constraints
        // formed during the reverse adjustment
        v_normals_.at(thisBlock) = v_normalsR_.at(thisBlock);
 
    }
 
    AtVinv->grow(0, pseudoMsrElemCount);
    measMinusComp->grow(pseudoMsrElemCount, 0);
 
    pseudomsrJSLCount = measMinusComp->rows() - v_measurementParams_.at(thisBlock);
 
    UINT32 jsl, jsl_cov1, jslvar, jslcovar, paramCount, paramCount2;
    it_vUINT32 _it_jsl(v_JSL_.at(nextBlock).begin()), _it_jsl_cov;
 
    paramCount = 0;
 
    // Copy the junction variances from nextBlock (from forward) to thisBlock
    for (_it_jsl=v_JSL_.at(nextBlock).begin(); 
        _it_jsl!=v_JSL_.at(nextBlock).end(); 
        ++_it_jsl, paramCount+=3)
    {
        // get index of this JSL in the next block
        jsl = v_blockStationsMap_.at(thisBlock)[*_it_jsl] * 3;
        jslvar = static_cast<UINT32>(std::distance(v_JSL_.at(nextBlock).begin(), _it_jsl) * 3);
 
        // add variances for this JSL to normals
        normals->blockadd(jsl, jsl, 
            v_junctionVariancesFwd_.at(nextBlock), jslvar, jslvar, 3, 3);
 
        // copy variances from v_junctionVariancesFwd_ to v_AtVinv_
        AtVinv->copyelements(jsl, pseudomsrJSLBegin + paramCount,
            v_junctionVariancesFwd_.at(nextBlock), jslvar, jslvar, 3, 3);
 
        // msr-comp elements
        // Measured-computed for junction stations carried forward (from thisBlock-1)
        // add station X measurement
        measMinusComp->put(pseudomsrJSLBegin + paramCount, 0, 
            (v_junctionEstimatesFwd_.at(nextBlock).get(jslvar, 0) -
            estimatedStations->get(jsl, 0)));           // X (meas - computed)
        
        // add station Y measurement
        measMinusComp->put(pseudomsrJSLBegin + paramCount+1, 0, 
            (v_junctionEstimatesFwd_.at(nextBlock).get(jslvar+1, 0) -
            estimatedStations->get(jsl+1, 0)));     // Y (meas - computed)
        
        // add station Z measurement
        measMinusComp->put(pseudomsrJSLBegin + paramCount+2, 0, 
            (v_junctionEstimatesFwd_.at(nextBlock).get(jslvar+2, 0) -
            estimatedStations->get(jsl+2, 0)));     // Z (meas - computed)
 
        paramCount2 = 0;
 
        // copy all covariances for this JSL in the next block
        for (_it_jsl_cov=_it_jsl; 
             _it_jsl_cov!=v_JSL_.at(nextBlock).end(); 
             ++_it_jsl_cov, paramCount2+=3)
        {
            // don't re-copy variances (i.e. diagonals)
            if (*_it_jsl_cov == *_it_jsl)
                continue;
            
            // get index of all covariances for this JSL in the next block
            jslcovar = static_cast<UINT32>(std::distance(v_JSL_.at(nextBlock).begin(), _it_jsl_cov) * 3);
            jsl_cov1 = v_blockStationsMap_.at(thisBlock)[*_it_jsl_cov] * 3;
            
            // add covariances for this JSL to normals
            normals->blockadd(jsl_cov1, jsl, v_junctionVariancesFwd_.at(nextBlock), jslcovar, jslvar, 3, 3);
            normals->blockadd(jsl, jsl_cov1, v_junctionVariancesFwd_.at(nextBlock), jslvar, jslcovar, 3, 3);
 
            // copy covariances from v_junctionVariancesFwd_ to v_AtVinv_
            AtVinv->copyelements(jsl_cov1, pseudomsrJSLBegin + paramCount, 
                v_junctionVariancesFwd_.at(nextBlock), jslcovar, jslvar, 3, 3);
 
            AtVinv->copyelements(jsl, pseudomsrJSLBegin + paramCount + paramCount2, 
                v_junctionVariancesFwd_.at(nextBlock), jslvar, jslcovar, 3, 3);
        }
    }
 
    if (projectSettings_.g.verbose > 0)
    {
        adj_file << std::endl << "Reverse block " << thisBlock;
        if (projectSettings_.a.stage)
            adj_file << " phased " << std::endl;
        else
            adj_file << " staged " << std::endl;
        adj_file << std::scientific << std::setprecision(16) << 
            "Design " << v_design_.at(thisBlock) << std::endl <<
            "AtVinv " << v_AtVinv_.at(thisBlock) << std::endl <<
            "Normals " << v_normals_.at(thisBlock) << std::endl;
    }
}

References adj_file, dynadjust::math::matrix_2d::blockadd(), dynadjust::math::matrix_2d::copyelements(), dynadjust::math::matrix_2d::get(), dynadjust::math::matrix_2d::grow(), projectSettings_, dynadjust::math::matrix_2d::put(), dynadjust::math::matrix_2d::rows(), v_AtVinv_, v_AtVinvR_, v_blockMeta_, v_blockStationsMap_, v_design_, v_estimatedStations_, v_estimatedStationsR_, v_JSL_, v_junctionEstimatesFwd_, v_junctionVariancesFwd_, v_measMinusComp_, v_measMinusCompR_, v_measurementParams_, v_normals_, v_normalsR_, and v_normalsRC_.

Referenced by PrepareAdjustmentCombine().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateAtVinv()

void dynadjust::networkadjust::dna_adjust::UpdateAtVinv	(	pit_vmsr_t	_it_msr,
		const UINT32 &	stn1,
		const UINT32 &	stn2,
		const UINT32 &	stn3,
		UINT32 &	design_row,
		matrix_2d *	design,
		matrix_2d *	AtVinv,
		bool	buildnewMatrices = true )

private

Definition at line 1434 of file dnaadjust.cpp.

{
    // variance
    double variance(1./(*_it_msr)->term2);
 
    if (buildnewMatrices)
        if (projectSettings_.g.verbose > 5)
            debug_file << "V" << (*_it_msr)->measType << " " << 
                std::fixed << std::setprecision(16) << std::setw(26) << variance << std::endl;
 
    // Build  At * V-1
    AtVinv->put(stn1, design_row, variance * design->get(design_row, stn1));
    AtVinv->put(stn1+1, design_row, variance * design->get(design_row, stn1+1));
    AtVinv->put(stn1+2, design_row, variance * design->get(design_row, stn1+2));
    
    // Single station measurements
    switch ((*_it_msr)->measType)
    {
    case 'H':   // Orthometric height
    case 'I':   // Astronomic latitude
    case 'J':   // Astronomic longitude
    case 'P':   // Geodetic latitude
    case 'Q':   // Geodetic longitude
    case 'R':   // Ellipsoidal height    
        return;
    }
 
    // Two station measurements
    AtVinv->put(stn2, design_row, variance * design->get(design_row, stn2));
    AtVinv->put(stn2+1, design_row, variance * design->get(design_row, stn2+1));
    AtVinv->put(stn2+2, design_row, variance * design->get(design_row, stn2+2));
 
    switch ((*_it_msr)->measType)
    {
    case 'A':   // Horizontal angle
        AtVinv->put(stn3, design_row, variance * design->get(design_row, stn3));
        AtVinv->put(stn3+1, design_row, variance * design->get(design_row, stn3+1));
        AtVinv->put(stn3+2, design_row, variance * design->get(design_row, stn3+2));
    }
}

References debug_file, dynadjust::math::matrix_2d::get(), projectSettings_, and dynadjust::math::matrix_2d::put().

Referenced by UpdateDesignNormalMeasMatrices_A(), UpdateDesignNormalMeasMatrices_BK(), UpdateDesignNormalMeasMatrices_CEM(), UpdateDesignNormalMeasMatrices_HR(), UpdateDesignNormalMeasMatrices_IP(), UpdateDesignNormalMeasMatrices_JQ(), UpdateDesignNormalMeasMatrices_L(), UpdateDesignNormalMeasMatrices_S(), UpdateDesignNormalMeasMatrices_V(), and UpdateDesignNormalMeasMatrices_Z().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateAtVinv_D()

void dynadjust::networkadjust::dna_adjust::UpdateAtVinv_D	(	const UINT32 &	stn1,
		const UINT32 &	stn2,
		const UINT32 &	stn3,
		const UINT32 &	angle,
		const UINT32 &	angle_count,
		UINT32 &	design_row,
		UINT32 &	design_row_begin,
		matrix_2d *	Vinv,
		matrix_2d *	design,
		matrix_2d *	AtVinv )

private

Definition at line 1477 of file dnaadjust.cpp.

{
    for (UINT32 j, i(0); i<3; ++i)                                                    // for each coordinate element (x, y, z)
    {
        // add variances
        AtVinv->elementadd(stn1+i, design_row,                                            // station1
            design->get(design_row, stn1+i) * Vinv->get(angle, angle));
        AtVinv->elementadd(stn2+i, design_row,                                            // station2
            design->get(design_row, stn2+i) * Vinv->get(angle, angle));
        AtVinv->elementadd(stn3+i, design_row,                                            // station3
            design->get(design_row, stn3+i) * Vinv->get(angle, angle));
        
        // add covariances
        for (j=0; j<angle_count; ++j)
        {
            if (j == angle)
                continue;
            AtVinv->elementadd(stn1+i, design_row_begin+j,                                // station1
                design->get(design_row, stn1+i) * Vinv->get(angle, j));
            AtVinv->elementadd(stn2+i, design_row_begin+j,                                // station2
                design->get(design_row, stn2+i) * Vinv->get(angle, j));
            AtVinv->elementadd(stn3+i, design_row_begin+j,                                // station3
                design->get(design_row, stn3+i) * Vinv->get(angle, j));
        }           
    }
}

References dynadjust::math::matrix_2d::elementadd(), and dynadjust::math::matrix_2d::get().

Referenced by UpdateDesignNormalMeasMatrices_D().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateNormals()

void dynadjust::networkadjust::dna_adjust::UpdateNormals	(	const UINT32 &	block,
		bool	MT_ReverseOrCombine )

private

Definition at line 1513 of file dnaadjust.cpp.

{
    UINT32 stn1, stn2, stn3, design_row(0);
    
    it_vUINT32 _it_block_msr;
    it_vmsr_t _it_msr;
 
    matrix_2d* normals(&v_normals_.at(block));
    matrix_2d* design(&v_design_.at(block));
    matrix_2d* AtVinv(&v_AtVinv_.at(block));
 
    if (MT_ReverseOrCombine)
    {
        normals = &v_normalsR_.at(block);
        design = &v_designR_.at(block);
        AtVinv = &v_AtVinvR_.at(block);
    }   
 
    for (_it_block_msr=v_CML_.at(block).begin(); _it_block_msr!=v_CML_.at(block).end(); ++_it_block_msr)
    {
        if (InitialiseandValidateMsrPointer(_it_block_msr, _it_msr))
            continue;
    
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr);
 
        switch (_it_msr->measType)
        {
        case 'H':   // Orthometric height
        case 'I':   // Astronomic latitude
        case 'J':   // Astronomic longitude
        case 'P':   // Geodetic latitude
        case 'Q':   // Geodetic longitude
        case 'R':   // Ellipsoidal height
            UpdateNormals_HIJPQR(stn1, design_row, normals, design, AtVinv);
            break;
 
        case 'A':   // Horizontal angle
            stn2 = GetBlkMatrixElemStn2(block, &_it_msr);
            stn3 = GetBlkMatrixElemStn3(block, &_it_msr);
            UpdateNormals_A(stn1, stn2, stn3, design_row, normals, design, AtVinv);
            break;
 
        case 'D':   // Direction set    
            // When a target direction is found, continue to next element.  
            if (_it_msr->vectorCount1 < 1)
                continue;
            UpdateNormals_D(block, _it_msr, design_row, normals, design, AtVinv);
            break;
 
        case 'B':   // Geodetic azimuth
        case 'C':   // Chord dist
        case 'E':   // Ellipsoid arc
        case 'K':   // Astronomic azimuth
        case 'L':   // Level difference
        case 'M':   // MSL arc
        case 'S':   // Slope distance
        case 'V':   // Zenith distance
        case 'Z':   // Vertical angle
            stn2 = GetBlkMatrixElemStn2(block, &_it_msr);
            UpdateNormals_BCEKLMSVZ(stn1, stn2, design_row, normals, design, AtVinv);
            break;
 
        case 'G':   // GPS Baseline
            // multiplies only the elements of AT * V-1 and A that contain this measurement
            stn2 = GetBlkMatrixElemStn2(block, &_it_msr);
            UpdateNormals_G(stn1, stn2, design_row, normals, AtVinv);
            break;
        
        case 'X':   // GPS Baseline cluster
            UpdateNormals_X(block, _it_msr, design_row, normals, design, AtVinv);
            break;
        
        case 'Y':   // GPS Point cluster
            UpdateNormals_Y(block, _it_msr, design_row, normals, AtVinv);
            break;      
        
        default:
            std::stringstream ss;
            ss << "UpdateNormals(): Unknown measurement type - '" << static_cast<std::string>(&(_it_msr->measType)) << 
                "'." << std::endl;
            SignalExceptionAdjustment(ss.str(), block);
        }       
    }   
}

References GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), GetBlkMatrixElemStn3(), InitialiseandValidateMsrPointer(), SignalExceptionAdjustment(), UpdateNormals_A(), UpdateNormals_BCEKLMSVZ(), UpdateNormals_D(), UpdateNormals_G(), UpdateNormals_HIJPQR(), UpdateNormals_X(), UpdateNormals_Y(), v_AtVinv_, v_AtVinvR_, v_CML_, v_design_, v_designR_, v_normals_, and v_normalsR_.

Referenced by RebuildNormals(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateNormals_A()

void dynadjust::networkadjust::dna_adjust::UpdateNormals_A	(	const UINT32 &	stn1,
		const UINT32 &	stn2,
		const UINT32 &	stn3,
		UINT32 &	design_row,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv )

private

Definition at line 1665 of file dnaadjust.cpp.

{
    // station 1
    AddMsrtoNormalsVar(design_row, stn1, normals, design, AtVinv);
    // station 2
    AddMsrtoNormalsVar(design_row, stn2, normals, design, AtVinv);
    // station 3
    AddMsrtoNormalsVar(design_row, stn3, normals, design, AtVinv);
    // covariance terms (station 1, station 2, station 3)
    AddMsrtoNormalsCoVar3(design_row, stn1, stn2, stn3, normals, design, AtVinv);
    design_row ++;
 
}

References AddMsrtoNormalsCoVar3(), and AddMsrtoNormalsVar().

Referenced by UpdateDesignNormalMeasMatrices_A(), and UpdateNormals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateNormals_BCEKLMSVZ()

void dynadjust::networkadjust::dna_adjust::UpdateNormals_BCEKLMSVZ	(	const UINT32 &	stn1,
		const UINT32 &	stn2,
		UINT32 &	design_row,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv )

private

Definition at line 1802 of file dnaadjust.cpp.

{
    // station 1
    AddMsrtoNormalsVar(design_row, stn1, normals, design, AtVinv);
    // station 2
    AddMsrtoNormalsVar(design_row, stn2, normals, design, AtVinv);
    // covariance terms (station 1 and station 2)
    AddMsrtoNormalsCoVar2(design_row, stn1, stn2, normals, design, AtVinv);
    design_row ++;
}

References AddMsrtoNormalsCoVar2(), and AddMsrtoNormalsVar().

Referenced by UpdateDesignNormalMeasMatrices_BK(), UpdateDesignNormalMeasMatrices_CEM(), UpdateDesignNormalMeasMatrices_L(), UpdateDesignNormalMeasMatrices_S(), UpdateDesignNormalMeasMatrices_V(), UpdateDesignNormalMeasMatrices_Z(), and UpdateNormals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateNormals_HIJPQR()

void dynadjust::networkadjust::dna_adjust::UpdateNormals_HIJPQR	(	const UINT32 &	stn1,
		UINT32 &	design_row,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv )

private

Definition at line 1816 of file dnaadjust.cpp.

{
    // station 1
    AddMsrtoNormalsVar(design_row, stn1, normals, design, AtVinv);
    design_row ++;
}

References AddMsrtoNormalsVar().

Referenced by UpdateDesignNormalMeasMatrices_HR(), UpdateDesignNormalMeasMatrices_IP(), UpdateDesignNormalMeasMatrices_JQ(), and UpdateNormals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateNormals_D()

void dynadjust::networkadjust::dna_adjust::UpdateNormals_D	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv )

private

Definition at line 1681 of file dnaadjust.cpp.

{
    UINT32 row, col, a, angle_count(_it_msr->vectorCount2 - 1);
    UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
 
    std::vector<UINT32> stations;
    UINT32 stn1, stn2, stn3;
 
    vmsr_t angleRec;
    angleRec.push_back(*_it_msr);
    it_vmsr_t it_angle(angleRec.begin());
 
    _it_msr++;
 
    // Build  At * V-1 * A variances and form list of 
    // stations to assist formulation of covariances
    for (a=0; a<angle_count; ++a)                                                                 // for each angle
    {
        // cater for ignored directions
        if (_it_msr->ignore)
        {
            while (skip < ignored)
            {
                skip++;
                _it_msr++;
                if (!_it_msr->ignore)
                    break;
            }
        }
 
        it_angle->station3 = _it_msr->station2;
 
        stn1 = (v_blockStationsMap_.at(block)[it_angle->station1] * 3); 
        stn2 = (v_blockStationsMap_.at(block)[it_angle->station2] * 3);
        stn3 = (v_blockStationsMap_.at(block)[it_angle->station3] * 3);
 
        if (!binary_search(stations.begin(), stations.end(), it_angle->station1))
        {
            stations.push_back(it_angle->station1);
            std::sort(stations.begin(), stations.end());
        }
        if (!binary_search(stations.begin(), stations.end(), it_angle->station2))
        {
            stations.push_back(it_angle->station2);
            std::sort(stations.begin(), stations.end());
        }
        if (!binary_search(stations.begin(), stations.end(), it_angle->station3))
        {
            stations.push_back(it_angle->station3);
            std::sort(stations.begin(), stations.end());
        }
 
        // station 1
        for (col=0; col<3; ++col)
            for (row=0; row<3; ++row)
                normals->elementadd(stn1+row, stn1+col,
                    AtVinv->get(stn1+row, design_row+a) * design->get(design_row+a, stn1+col));
        //
        // station 2
        for (col=0; col<3; ++col)
            for (row=0; row<3; ++row)
                normals->elementadd(stn2+row, stn2+col,
                    AtVinv->get(stn2+row, design_row+a) * design->get(design_row+a, stn2+col));
        //
        // station 3
        for (col=0; col<3; ++col)
            for (row=0; row<3; ++row)
                normals->elementadd(stn3+row, stn3+col,
                    AtVinv->get(stn3+row, design_row+a) * design->get(design_row+a, stn3+col));
 
        if (a+1 == angle_count)
            break;
 
        // prepare for next angle
        angleRec.push_back(*_it_msr);
        it_angle = angleRec.end() - 1;
 
        _it_msr++;  
    }
 
    it_vUINT32 it_stn, it_cov;
    it_angle = angleRec.begin();
    
    // Build  At * V-1 * A covariances
    for (a=0; a<angle_count; ++a)                                                                 // for each angle
    {
        //
        // covariance terms (station 1, station 2, station 3)
        // requires std::vector<UINT32> stations which was built during formation of v_AtVinv_
        for (it_stn=stations.begin(); it_stn!=stations.end(); ++it_stn)
        {
            stn1 = (v_blockStationsMap_.at(block)[*it_stn] * 3);
 
            for (it_cov=it_stn; it_cov!=stations.end(); ++it_cov)
            {
                stn2 = (v_blockStationsMap_.at(block)[*it_cov] * 3);
                if (stn2 == stn1)
                    continue;
 
                for (col=0; col<3; ++col)
                {
                    for (row=0; row<3; ++row)
                    {
                        // 1-2
                        normals->elementadd(stn1+row, stn2+col,
                            AtVinv->get(stn1+row, design_row+a) * design->get(design_row+a, stn2+col));
                        normals->elementadd(stn2+row, stn1+col,
                            AtVinv->get(stn2+row, design_row+a) * design->get(design_row+a, stn1+col));
                    }               
                }
            }
        }
        it_angle++;
    }
 
    design_row += angle_count;
}

References dynadjust::math::matrix_2d::elementadd(), dynadjust::math::matrix_2d::get(), and v_blockStationsMap_.

Referenced by UpdateDesignNormalMeasMatrices_D(), and UpdateNormals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateNormals_G()

void dynadjust::networkadjust::dna_adjust::UpdateNormals_G	(	const UINT32 &	stn1,
		const UINT32 &	stn2,
		UINT32 &	design_row,
		matrix_2d *	normals,
		matrix_2d *	AtVinv )

private

Definition at line 1825 of file dnaadjust.cpp.

{
    UINT32 col, row;
 
    // station 2
    for (col=0; col<3; ++col)
        for (row=0; row<3; ++row)
            normals->elementadd(stn2+row, stn2+col,
                // AtVinv->get(stn2+row, design_row+col) * design->get(design_row+col, stn2+col));
                // No need to multiply by 1 as stn2 design element is always 1.  See UpdateDesignMeasMatrices_GX()
                AtVinv->get(stn2+row, design_row+col));
 
    // station 1
    for (col=0; col<3; ++col)
        for (row=0; row<3; ++row)
            normals->elementadd(stn1+row, stn1+col,
                // AtVinv->get(stn1+row, design_row+col) * design->get(design_row+col, stn1+col));
                // No need to multiply by -1 as stn1 design element is always -1.  See UpdateDesignMeasMatrices_GX()
                -AtVinv->get(stn1+row, design_row+col));
 
    // covariance terms (station 1 and station 2)
    for (col=0; col<3; ++col)
        for (row=0; row<3; ++row)
            normals->elementadd(stn1+row, stn2+col,
                // AtVinv->get(stn1+row, design_row+col) * design->get(design_row+col, stn2+col));
                // No need to multiply as stn2 is always 1.  See UpdateDesignMeasMatrices_GX()
                AtVinv->get(stn1+row, design_row+col));
 
    // covariance terms (station 2 and station 1)
    for (col=0; col<3; ++col)
        for (row=0; row<3; ++row)
            normals->elementadd(stn2+row, stn1+col,
                // AtVinv->get(stn2+row, design_row+col) * design->get(design_row+col, stn1+col));
                // No need to multiply by -1 as stn1 design element is always -1.  See UpdateDesignMeasMatrices_GX()
                -AtVinv->get(stn2+row, design_row+col));
 
    design_row += 3;
}

References dynadjust::math::matrix_2d::elementadd(), and dynadjust::math::matrix_2d::get().

Referenced by UpdateDesignNormalMeasMatrices_G(), and UpdateNormals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateNormals_X()

void dynadjust::networkadjust::dna_adjust::UpdateNormals_X	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		matrix_2d *	normals,
		matrix_2d *	design,
		matrix_2d *	AtVinv )

private

Definition at line 1866 of file dnaadjust.cpp.

{
    UINT32 cluster_bsl, baseline_count(_it_msr->vectorCount1);
    UINT32 cluster_cov, covariance_count;
    UINT32 stn1, stn2, covr(0);
 
    vUINT32 baseline_stations;
 
    baseline_stations.push_back(GetBlkMatrixElemStn1(block, &_it_msr));
    baseline_stations.push_back(GetBlkMatrixElemStn2(block, &_it_msr));
    std::sort(baseline_stations.begin(), baseline_stations.end());
 
    matrix_2d tmp(3, 3);
 
    // Build  At * V-1 * A variances
    for (cluster_bsl=0; cluster_bsl<baseline_count; ++cluster_bsl)
    {
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr);
        stn2 = GetBlkMatrixElemStn2(block, &_it_msr);
    
        // create a unique list of stations used in this cluster
        if (!binary_search(baseline_stations.begin(), baseline_stations.end(), stn1))
        {
            baseline_stations.push_back(stn1);
            std::sort(baseline_stations.begin(), baseline_stations.end());
        }
 
        if (!binary_search(baseline_stations.begin(), baseline_stations.end(), stn2))
        {
            baseline_stations.push_back(stn2);
            std::sort(baseline_stations.begin(), baseline_stations.end());
        }
 
        covr = cluster_bsl * 3;
 
        // add variances for these stations
        //normals->blockadd(stn1, stn1,                         // Station 1.  This variance matrix
        //  AtVinv->submatrix(stn1,                             // component must be multiplied by -1 to
        //      design_row+covr, 3, 3).scale(-1.), 0, 0, 3, 3); // effect the design matrix elements
        
        // copy the relevant AtV-1 elements to temp and multiply 
        // by -1 to effect the design matrix elements
        AtVinv->submatrix(stn1, design_row+covr, &tmp, 3, 3);
        tmp.scale(-1.);
 
        // add variances for these stations
        normals->blockadd(stn1, stn1,                           // Station 1.
            tmp, 0, 0, 3, 3);
        normals->blockadd(stn2, stn2,                           // Station 2
            *AtVinv, stn2, design_row+covr, 3, 3);  
 
        covariance_count = _it_msr->vectorCount2;
        _it_msr += 3;           // move to covariances
 
        for (cluster_cov=0; cluster_cov<covariance_count; ++cluster_cov)
            _it_msr += 3;
    }
 
    matrix_2d tmp1(3, baseline_count*3), tmp2(baseline_count*3, 3);
 
    // Build  At * V-1 * A covariances
    for (cluster_bsl=0; cluster_bsl<baseline_stations.size(); ++cluster_bsl)
    {
        stn1 = baseline_stations.at(cluster_bsl);
 
        for (cluster_cov=0; cluster_cov<baseline_stations.size(); ++cluster_cov)
        {
            if (cluster_cov==cluster_bsl)
                continue;
 
            stn2 = baseline_stations.at(cluster_cov);
            //normals->blockadd(stn1, stn2,     
            //  AtVinv->submatrix(stn1,         
            //      design_row, 3, baseline_count*3).multiply(
            //          design->submatrix(design_row, stn2, 
            //              baseline_count*3, 3)), 0, 0, 3, 3);
 
            // The following is more code, but is more efficient as it
            // recycles matrix instances (as opposed to creating a
            // new instance for every call to submatrix and multiply)
            // Get AtVinv component
            AtVinv->submatrix(stn1, design_row, 
                &tmp1, 3, baseline_count*3);
            // Get design component
            design->submatrix(design_row, stn2, 
                &tmp2, baseline_count*3, 3);
            // multiply the components to form covariance
            // for stations stn1 and stn2
            //tmp.multiply(tmp1, tmp2);
            tmp.multiply(tmp1, "N", tmp2, "N");
            // Now add covariances to normals
            normals->blockadd(stn1, stn2,       
                tmp, 0, 0, 3, 3);
        }
    }
 
    design_row += baseline_count * 3;
}

References dynadjust::math::matrix_2d::blockadd(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), dynadjust::math::matrix_2d::multiply(), dynadjust::math::matrix_2d::scale(), and dynadjust::math::matrix_2d::submatrix().

Referenced by UpdateNormals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateNormals_Y()

void dynadjust::networkadjust::dna_adjust::UpdateNormals_Y	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		matrix_2d *	normals,
		matrix_2d *	AtVinv )

private

Definition at line 1969 of file dnaadjust.cpp.

{
    UINT32 cluster_pnt, point_count(_it_msr->vectorCount1);
    UINT32 cluster_cov, covariance_count;
    UINT32 stn1, stn2, cov_c;
 
    // Add to At * V-1 * A
    for (cluster_pnt=0; cluster_pnt<point_count; ++cluster_pnt)
    {       
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr);
        covariance_count = _it_msr->vectorCount2;
        
        // add variance for this station
        normals->blockadd(stn1, stn1, *AtVinv, stn1, design_row, 3, 3);
 
        if (projectSettings_.g.verbose > 4)
            debug_file << "- Adding variances for " << bstBinaryRecords_.at(_it_msr->station1).stationName << " to v_normals_ (block " << block+1 << "), (" << stn1 << ", " << stn1 << "): " << 
                std::fixed << std::setprecision(16) << AtVinv->submatrix(stn1, design_row, 3, 3);
 
        if (covariance_count < 1)
        {
            design_row += 3;
            break;
        }
 
        _it_msr += 3;
        cov_c = 0;
 
        for (cluster_cov=0; cluster_cov<covariance_count; ++cluster_cov)    // number of baseline/point covariances
        {
            stn2 = GetBlkMatrixElemStn1(block, &_it_msr);       // this becomes stn1 in next cluster_pnt loop
            cov_c += 3;
 
            // add covariance between stn1 and this station
            normals->blockadd(stn1, stn2, *AtVinv, stn1, design_row + cov_c, 3, 3);
            normals->blockadd(stn2, stn1, *AtVinv, stn2, design_row, 3, 3);
            
            _it_msr += 3;
        }
        design_row += 3;
    }
}

References dynadjust::math::matrix_2d::blockadd(), bstBinaryRecords_, debug_file, GetBlkMatrixElemStn1(), projectSettings_, and dynadjust::math::matrix_2d::submatrix().

Referenced by UpdateNormals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OutputLargestCorrection()

void dynadjust::networkadjust::dna_adjust::OutputLargestCorrection ( std::string & formatted_msg )

private

Definition at line 8329 of file dnaadjust.cpp.

{
    UINT32 stnIndex(0), x_coordElement(0);
 
    // load corrections matrix for block blockLargeCorr_
    if (projectSettings_.a.stage)
        DeserialiseBlockFromMappedFile(blockLargeCorr_, 1, 
            sf_corrections);
 
    // print maximum correction
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Maximum station correction";
 
    // which station?
    stnIndex = (UINT32)floor(v_corrections_.at(blockLargeCorr_).maxvalueRow() / 3.);
    stnIndex = v_parameterStationList_.at(blockLargeCorr_).at(stnIndex);
    x_coordElement = (UINT32)(v_corrections_.at(blockLargeCorr_).maxvalueRow() % 3);
 
    switch (projectSettings_.a.adjust_mode)
    {
    case Phased_Block_1Mode:
    case PhasedMode:
        adj_file << "Block " << blockLargeCorr_+1 << 
            ", station " << bstBinaryRecords_.at(stnIndex).stationName;
        break;
    case SimultaneousMode:
    default:
        adj_file << "Station " << bstBinaryRecords_.at(stnIndex).stationName;
        break;
    }
 
    adj_file << std::endl << std::setw(PRINT_VAR_PAD) << " ";
 
    // calculate error vector in local reference frame
    matrix_2d cart(3, 1), local(3, 1);
    switch (x_coordElement)
    {
    case 0:
        x_coordElement = v_corrections_.at(blockLargeCorr_).maxvalueRow();
        break;
    case 1:
        x_coordElement = v_corrections_.at(blockLargeCorr_).maxvalueRow() - 1;
        break;
    case 2:
        x_coordElement = v_corrections_.at(blockLargeCorr_).maxvalueRow() - 2;
        break;
    }
 
    cart.put(0, 0, v_corrections_.at(blockLargeCorr_).get(x_coordElement, 0));
    cart.put(1, 0, v_corrections_.at(blockLargeCorr_).get(x_coordElement+1, 0));
    cart.put(2, 0, v_corrections_.at(blockLargeCorr_).get(x_coordElement+2, 0));
 
    // OK, finished with the corrections, so unload if staged
    if (projectSettings_.a.stage)
        UnloadBlock(blockLargeCorr_, 1, sf_corrections);
 
    Rotate_CartLocal<double>(cart, &local,
        bstBinaryRecords_.at(stnIndex).currentLatitude,
        bstBinaryRecords_.at(stnIndex).currentLongitude);  
 
    double largestCorr = local.compute_maximum_value();
    
    if (fabs(largestCorr) > 0.000999)
        adj_file << std::fixed << std::setprecision(3) << 
            local.get(0, 0) << ", " << local.get(1, 0) << ", " << local.get(2, 0);
    else if (fabs(largestCorr) > 0.00009)
        adj_file << std::fixed << std::setprecision(4) << 
            local.get(0, 0) << ", " << local.get(1, 0) << ", " << local.get(2, 0);
    else
        adj_file << std::scientific << std::setprecision(1) << 
            local.get(0, 0) << ", " << local.get(1, 0) << ", " << local.get(2, 0);
    
 
    adj_file << " (e, n, up)" << std::endl << std::endl;
 
    std::stringstream ss;
    ss << std::fixed << std::setprecision(PRECISION_MTR_STN) << local.get(local.maxvalueRow(), 0) << " ";
 
    switch (local.maxvalueRow())
    {
    case 0:
        ss << std::setw(2) << std::left << "e";
        break;
    case 1:
        ss << std::setw(2) << std::left << "n";
        break;
    case 2:
        ss << std::setw(2) << std::left << "up";
        break;
    }
 
    formatted_msg = ss.str();
}

References adj_file, blockLargeCorr_, bstBinaryRecords_, dynadjust::math::matrix_2d::compute_maximum_value(), DeserialiseBlockFromMappedFile(), dynadjust::math::matrix_2d::get(), dynadjust::math::matrix_2d::maxvalueRow(), Phased_Block_1Mode, PhasedMode, PRECISION_MTR_STN, PRINT_VAR_PAD(), projectSettings_, Rotate_CartLocal(), sf_corrections, SimultaneousMode, UnloadBlock(), v_corrections_, and v_parameterStationList_.

Referenced by AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), and AdjustSimultaneous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareDesignAndMsrMnsCmpMatrices()

void dynadjust::networkadjust::dna_adjust::PrepareDesignAndMsrMnsCmpMatrices ( const UINT32 & block )

private

Definition at line 982 of file dnaadjust.cpp.

{
    UINT32 pseudoMsrElemCount(0), pseudoMsrCount(0);
 
    switch (projectSettings_.a.adjust_mode)
    {
    case SimultaneousMode:
 
        // redimension the measurements matrix
        v_measMinusComp_.at(block).redim(
            v_measurementCount_.at(block), 1);   
        
        // redimension the At*V-1 matrix
        v_AtVinv_.at(block).redim(
            v_unknownsCount_.at(block), 
            v_measurementCount_.at(block));  
 
        break;
    case Phased_Block_1Mode:
    case PhasedMode:
        // Phased mode also includes sequential phased adjustment in
        // stage and multi-thread mode
 
        // Prepare all blocks except the first and any isolated blocks
        if (!v_blockMeta_.at(block)._blockIsolated)
        {
            // During forward and reverse (in isolation) adjustments, this block will include
            // JSLs as measurements from either v_JSL_.at(block-1) or v_JSL_.at(block).
            // During combination adjustments, this block will include JSLs as measurements 
            // from both.  So set pseudomsrJSLCount to be the sum of both and grow/shrink accordingly
            pseudoMsrCount = static_cast<UINT32>(v_JSL_.at(block).size());
 
            if (!v_blockMeta_.at(block)._blockFirst)
                pseudoMsrCount += static_cast<UINT32>(v_JSL_.at(block-1).size());
 
            pseudoMsrElemCount = pseudoMsrCount * 3;
        }
 
        // Is this a staged adjustment for which the matrix data is to be loaded from
        // existing stage files created from a previous run?
        if (projectSettings_.a.stage)
        {
            // Staged adjustments only.
            // Load matrix data from existing .mtx stage files 
            // created from a previous run.
            
            // redimension the measurements matrix
            if (projectSettings_.a.recreate_stage_files)
                v_measMinusComp_.at(block).redim(
                    v_measurementCount_.at(block) + pseudoMsrElemCount,  1); // real measurements + JSLs (fwd + reverse)
            else
                v_measMinusComp_.at(block).setsize(
                    v_measurementCount_.at(block) + pseudoMsrElemCount,  1);
 
            // redimension the At*V-1 matrix
            v_AtVinv_.at(block).setsize(
                v_unknownsCount_.at(block), 
                v_measurementCount_.at(block) + pseudoMsrElemCount); // real measurements + JSLs (fwd + reverse)
        }
        else
        {       
            // redimension the measurements matrix
            v_measMinusComp_.at(block).redim(
                v_measurementCount_.at(block) + pseudoMsrElemCount,  1); // real measurements + JSLs (fwd + reverse)
 
            // redimension the At*V-1 matrix
            v_AtVinv_.at(block).redim(
                v_unknownsCount_.at(block), 
                v_measurementCount_.at(block) + pseudoMsrElemCount); // real measurements + JSLs (fwd + reverse)
        }
 
        if (pseudoMsrElemCount > 0)
        {
            // Now reset these matrices back to actual measurement dimensions.
            // The forward, reverse and combination pass will use grow() to incorporate 
            // JSLs from previous and next blocks as required
            v_AtVinv_.at(block).shrink(0, pseudoMsrElemCount);
            v_measMinusComp_.at(block).shrink(pseudoMsrElemCount, 0);
        }
 
        // Store pseudo measurement count
        v_pseudoMeasCountFwd_.at(block) = pseudoMsrCount;
    }
 
    // Is this a phased adjustment in stage mode?
    if (projectSettings_.a.stage)
    {
        PrepareDesignAndMsrMnsCmpMatricesStage(block);
        return;
    }
    
    // Simultaneous, phased (multithreaded and block1) adjustments
 
    // Redim all matrices
    v_normals_.at(block).redim(v_unknownsCount_.at(block), v_unknownsCount_.at(block));   
    v_design_.at(block).redim(v_measurementCount_.at(block), v_unknownsCount_.at(block));
    v_corrections_.at(block).redim(v_unknownsCount_.at(block), 1);
    v_precAdjMsrsFull_.at(block).redim(v_measurementVarianceCount_.at(block), 1);
    
    // All blocks in v_correctionsR_ are used for multi thread mode, but only the last is used
    // in single thread mode
    if (projectSettings_.a.adjust_mode == PhasedMode && 
        projectSettings_.a.adjust_mode != Phased_Block_1Mode)
    {
        if (v_blockMeta_.at(block)._blockLast)
            v_correctionsR_.at(block).redim(v_unknownsCount_.at(block), 1);
 
        else if (projectSettings_.a.multi_thread)
            v_correctionsR_.at(block).redim(v_unknownsCount_.at(block), 1);
    }
    
 
    // Now, form the design matrices
    FillDesignNormalMeasurementsMatrices(true, block, false);
    
}

References FillDesignNormalMeasurementsMatrices(), Phased_Block_1Mode, PhasedMode, PrepareDesignAndMsrMnsCmpMatricesStage(), projectSettings_, SimultaneousMode, v_AtVinv_, v_blockMeta_, v_corrections_, v_correctionsR_, v_design_, v_JSL_, v_measMinusComp_, v_measurementCount_, v_measurementVarianceCount_, v_normals_, v_precAdjMsrsFull_, v_pseudoMeasCountFwd_, and v_unknownsCount_.

Referenced by PrepareAdjustmentBlock().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrepareDesignAndMsrMnsCmpMatricesStage()

void dynadjust::networkadjust::dna_adjust::PrepareDesignAndMsrMnsCmpMatricesStage ( const UINT32 & block )

private

Definition at line 1100 of file dnaadjust.cpp.

{
    // Resize all matrices, which will be filled as and when needed
    v_normals_.at(block).setsize(v_unknownsCount_.at(block), v_unknownsCount_.at(block));
    v_design_.at(block).setsize(v_measurementCount_.at(block), v_unknownsCount_.at(block));
    
    // Does the matrix data need to be loaded from existing stage files
    // created from a previous run?
    if (projectSettings_.a.recreate_stage_files || !bms_meta_.reduced)
    {
        // Redim NormalsR
        v_normalsR_.at(block).redim(
            v_unknownsCount_.at(block), 
            v_unknownsCount_.at(block));
 
        // Redimension the corrections matrices
        v_corrections_.at(block).redim(v_unknownsCount_.at(block), 1);
        if (v_blockMeta_.at(block)._blockLast)
            v_correctionsR_.at(block).redim(v_unknownsCount_.at(block), 1);
 
        // Redimension precision of adjusted measurements
        v_precAdjMsrsFull_.at(block).redim(v_measurementVarianceCount_.at(block), 1);
    }
    else
    {
        // Resize the normals back-up matrix
        v_normalsR_.at(block).setsize(
            v_unknownsCount_.at(block), 
            v_unknownsCount_.at(block));
 
        // Resize the corrections matrices
        v_corrections_.at(block).setsize(v_unknownsCount_.at(block), 1);
        if (v_blockMeta_.at(block)._blockLast)
            v_correctionsR_.at(block).setsize(v_unknownsCount_.at(block), 1);
 
        // Resize precision of adjusted measurements
        v_precAdjMsrsFull_.at(block).setsize(v_measurementVarianceCount_.at(block), 1);
    }
 
    if (projectSettings_.a.recreate_stage_files || !bms_meta_.reduced)
        // Creating new memory mapped files?  Form the design matrices
        FillDesignNormalMeasurementsMatrices(true, block, false);
}

References bms_meta_, FillDesignNormalMeasurementsMatrices(), projectSettings_, v_blockMeta_, v_corrections_, v_correctionsR_, v_design_, v_measurementCount_, v_measurementVarianceCount_, v_normals_, v_normalsR_, v_precAdjMsrsFull_, and v_unknownsCount_.

Referenced by PrepareDesignAndMsrMnsCmpMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FillDesignNormalMeasurementsMatrices()

void dynadjust::networkadjust::dna_adjust::FillDesignNormalMeasurementsMatrices	(	bool	buildnewMatrices,
		const UINT32 &	block,
		bool	MT_ReverseOrCombine )

private

Definition at line 4824 of file dnaadjust.cpp.

{
    UINT32 design_row(0);
    
    it_vUINT32 _it_block_msr;
    it_vmsr_t _it_msr; 
 
    for (_it_block_msr=v_CML_.at(block).begin(); _it_block_msr!=v_CML_.at(block).end(); ++_it_block_msr)
    {
        if (InitialiseandValidateMsrPointer(_it_block_msr, _it_msr))
            continue;
 
        // When a target direction is found, continue to next element.  
        if (_it_msr->measType == 'D')
            if (_it_msr->vectorCount2 < 1)
                continue;
 
        // Build AtVinv, Normals and Meas minus Comp vectors
        UpdateDesignNormalMeasMatrices(&_it_msr, design_row, buildnewMatrices, block, MT_ReverseOrCombine);
    }
}

References InitialiseandValidateMsrPointer(), UpdateDesignNormalMeasMatrices(), and v_CML_.

Referenced by ComputeAdjustedMsrPrecisions(), PrepareDesignAndMsrMnsCmpMatrices(), PrepareDesignAndMsrMnsCmpMatricesStage(), RebuildNormals(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddConstraintStationstoNormalsForward()

void dynadjust::networkadjust::dna_adjust::AddConstraintStationstoNormalsForward ( const UINT32 & block )

private

Definition at line 2063 of file dnaadjust.cpp.

{
    it_vUINT32 _it_const;
    it_vstn_appear _it_appear;
    
    UINT32 stn;
    matrix_2d var_cart(3, 3);
 
    for (_it_const=v_parameterStationList_.at(block).begin(),
        _it_appear=v_paramStnAppearance_.at(block).begin(); 
        _it_const!=v_parameterStationList_.at(block).end(); 
        ++_it_const, ++_it_appear)
    {
 
        // In phased adjustment mode, parameter station variances only 
        // need to be added once
        if (!_it_appear->first_appearance_fwd)
            continue;
        
        // compute _var_cart for this station
        FormConstraintStationVarianceMatrix(_it_const, var_cart);
 
        if (projectSettings_.g.verbose > 6)
            debug_file << "parameter station " << bstBinaryRecords_.at((*_it_const)).stationName << std::scientific << std::setprecision(16) << var_cart << std::endl;
        
        // Add the variance to the normals
        stn = v_blockStationsMap_.at(block)[(*_it_const)] * 3;
        v_normals_.at(block).blockadd(stn, stn, var_cart, 0, 0, 3, 3);
    }
}

References bstBinaryRecords_, debug_file, FormConstraintStationVarianceMatrix(), projectSettings_, v_blockStationsMap_, v_normals_, v_parameterStationList_, and v_paramStnAppearance_.

Referenced by PrepareAdjustmentBlock(), RebuildNormals(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddConstraintStationstoNormalsReverse()

void dynadjust::networkadjust::dna_adjust::AddConstraintStationstoNormalsReverse	(	const UINT32 &	block,
		bool	MT_ReverseOrCombine )

private

Definition at line 2100 of file dnaadjust.cpp.

{
    it_vUINT32 _it_const;
    it_vstn_appear _it_appear;
    
    UINT32 stn;
    matrix_2d var_cart(3, 3);
    matrix_2d* normals(&v_normals_.at(block));
 
    if (MT_ReverseOrCombine)
        normals = &v_normalsR_.at(block);    
 
    for (_it_const=v_parameterStationList_.at(block).begin(),
        _it_appear=v_paramStnAppearance_.at(block).begin(); 
        _it_const!=v_parameterStationList_.at(block).end(); 
        ++_it_const, ++_it_appear)
    {
        // In phased adjustment mode, parameter station variances only 
        // need to be added once
        if (!_it_appear->first_appearance_rev)
            continue;       
        
        // compute _var_cart for this station
        FormConstraintStationVarianceMatrix(_it_const, var_cart);
 
        // Add the variance to the normals
        stn = v_blockStationsMap_.at(block)[(*_it_const)] * 3;
        normals->blockadd(stn, stn, var_cart, 0, 0, 3, 3);
    }
}

References dynadjust::math::matrix_2d::blockadd(), FormConstraintStationVarianceMatrix(), v_blockStationsMap_, v_normals_, v_normalsR_, v_parameterStationList_, and v_paramStnAppearance_.

Referenced by CarryReverseJunctions(), PrepareAdjustmentReverse(), and RebuildNormals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddConstraintStationstoNormalsCombine()

void dynadjust::networkadjust::dna_adjust::AddConstraintStationstoNormalsCombine	(	const UINT32 &	block,
		bool	MT_ReverseOrCombine )

private

Definition at line 2137 of file dnaadjust.cpp.

{
    it_vUINT32 _it_const;
    it_vstn_appear _it_appear;
    
    UINT32 stn;
    matrix_2d var_cart(3, 3);
    matrix_2d* normals(&v_normals_.at(block));
 
    if (MT_ReverseOrCombine)
        normals = &v_normalsR_.at(block);    
 
    for (_it_const=v_parameterStationList_.at(block).begin(),
        _it_appear=v_paramStnAppearance_.at(block).begin(); 
        _it_const!=v_parameterStationList_.at(block).end(); 
        ++_it_const, ++_it_appear)
    {
 
        // In combination adjustment, parameter station variances only need to be added 
        // if this station appears for the first time in both forward and reverse runs,
        // and subtracted if it appears for the first time in reverse but not in forward
 
        // If this station appears for the first time in a forward pass, then
        // constraints have not yet been added for this station in the forward pass.
        // So, continue to the next station (do nothing)
        if (_it_appear->first_appearance_fwd)
            continue;
        
        // At this point, this station has appeared in a previous block in a forward pass,
        // in which case, constraints would have been added and the effect carried through.
        // So, remove the effect.
 
        // compute _var_cart for this station
        FormConstraintStationVarianceMatrix(_it_const, var_cart);
 
        // Add the variance to the normals
        stn = v_blockStationsMap_.at(block)[(*_it_const)] * 3;
 
        if (!_it_appear->first_appearance_fwd)
            normals->blocksubtract(stn, stn, var_cart,
                0, 0, 3, 3);
    }
}

References dynadjust::math::matrix_2d::blocksubtract(), FormConstraintStationVarianceMatrix(), v_blockStationsMap_, v_normals_, v_normalsR_, v_parameterStationList_, and v_paramStnAppearance_.

Referenced by PrepareAdjustmentCombine().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddConstraintStationstoNormalsSimultaneous()

void dynadjust::networkadjust::dna_adjust::AddConstraintStationstoNormalsSimultaneous ( const UINT32 & block )

private

Definition at line 2187 of file dnaadjust.cpp.

{
    it_vUINT32 _it_const;
    
    UINT32 stn;
    matrix_2d var_cart(3, 3);
 
    for (_it_const=v_parameterStationList_.at(block).begin(); 
        _it_const!=v_parameterStationList_.at(block).end(); 
        ++_it_const)
    {
 
        // compute _var_cart for this station
        FormConstraintStationVarianceMatrix(_it_const, var_cart);
 
        if (projectSettings_.g.verbose > 6)
            debug_file << "parameter station " << bstBinaryRecords_.at((*_it_const)).stationName << std::scientific << std::setprecision(16) << var_cart << std::endl;
        
        // Add the variance to the normals
        stn = v_blockStationsMap_.at(block)[(*_it_const)] * 3;
        v_normals_.at(block).blockadd(stn, stn, var_cart, 0, 0, 3, 3);
    }
}

References bstBinaryRecords_, debug_file, FormConstraintStationVarianceMatrix(), projectSettings_, v_blockStationsMap_, v_normals_, and v_parameterStationList_.

Referenced by PrepareAdjustmentBlock(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FormConstraintStationVarianceMatrix()

void dynadjust::networkadjust::dna_adjust::FormConstraintStationVarianceMatrix	(	const it_vUINT32 &	_it_param_stn,
		matrix_2d &	var_cart )

private

Definition at line 2213 of file dnaadjust.cpp.

{
    vstn_t::const_iterator _it_stn(bstBinaryRecords_.begin() + (*_it_param_stn));
    
    // Constrain this station so that it will not move?
    if (_it_stn->stationConst[0] == 'C' &&
        _it_stn->stationConst[1] == 'C' &&
        _it_stn->stationConst[2] == 'C') 
    {
        // set to inverse of 'constrained' variance matrix
        var_cart = _inv_var_cart_c;
        return;
    }
    
    // free; no constraint.
    if (_it_stn->stationConst[0] == 'F' &&
        _it_stn->stationConst[1] == 'F' &&
        _it_stn->stationConst[2] == 'F')
    {
        // set to inverse of 'free' variance matrix
        var_cart = _inv_var_cart_f;
        return;
    }
    
    // If this point is reached, the station constraints will be a
    // combination of F and C.  In this case, form a variance matrix
    // in the local reference frame and propagate to the cartesian
    
    // CCF = constrained horizontally
    // FFC = constrained vertically
    
    // For CF* and FC* (irrespective of height), read on...
    //
    // If FCC is supplied for geographic coordinates, then:
    //  - latitude (north-south) is Free 
    //  - longitude (east-west) is Constrained
    //
    // If FCC is supplied for projection coordinates, then:
    //  - easting (east-west) is Free
    //  - northing (north-south) is Constrained
 
    matrix_2d var_local(3, 3);
 
    // first element
    if (_it_stn->stationConst[0] == 'F')
    {
        if (_it_stn->suppliedStationType == LLH_type_i)
            var_local.put(1, 1, _var_F);  // Latitude:  'F'ree in the north-south (n/y) direction
        else
            var_local.put(0, 0, _var_F);  // Easting/X: 'F'ree in the east-west or X direction
    }
    else
    {
        if (_it_stn->suppliedStationType == LLH_type_i)
            var_local.put(1, 1, _var_C);  // Latitude:  'C'onstrained in the north-south (n/y) direction
        else
            var_local.put(0, 0, _var_C);  // Easting/X: 'C'onstrained in the east-west or X direction
    }
 
    // second element
    if (_it_stn->stationConst[1] == 'F')
    {
        if (_it_stn->suppliedStationType == LLH_type_i)
            var_local.put(0, 0, _var_F);
        else
            var_local.put(1, 1, _var_F);
    }
    else
    {
        if (_it_stn->suppliedStationType == LLH_type_i)
            var_local.put(0, 0, _var_C);
        else
            var_local.put(1, 1, _var_C);
    }
    
    // ellipsoidal height - corresponds to up, whether coordinates are geographic, projection or cartesian
    if (_it_stn->stationConst[2] == 'F')
        var_local.put(2, 2, _var_F);
    else
        var_local.put(2, 2, _var_C);
 
    // If station is in cartesian, assume constraints are in cartesian reference frame
    if (_it_stn->suppliedStationType == XYZ_type_i)
        var_cart = var_local;
    else
        // Propagate variance in local reference frame to cartesian reference frame
        PropagateVariances_LocalCart<double>(var_local, var_cart, 
            _it_stn->currentLatitude, _it_stn->currentLongitude, 
            true);      // local to cart
 
    FormInverseVarianceMatrix(&var_cart);
}

References _inv_var_cart_c, _inv_var_cart_f, _var_C, _var_F, bstBinaryRecords_, FormInverseVarianceMatrix(), LLH_type_i, PropagateVariances_LocalCart(), dynadjust::math::matrix_2d::put(), and XYZ_type_i.

Referenced by AddConstraintStationstoNormalsCombine(), AddConstraintStationstoNormalsForward(), AddConstraintStationstoNormalsReverse(), and AddConstraintStationstoNormalsSimultaneous().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateNormalsR()

void dynadjust::networkadjust::dna_adjust::UpdateNormalsR ( const UINT32 & block )

private

◆ UpdateNormalsC()

void dynadjust::networkadjust::dna_adjust::UpdateNormalsC ( const UINT32 & block )

private

◆ CarryStnEstimatesandVariancesReverseR()

void dynadjust::networkadjust::dna_adjust::CarryStnEstimatesandVariancesReverseR	(	const UINT32 &	nextBlock,
		const UINT32 &	thisBlock )

private

◆ fillSinexExample()

static void dynadjust::networkadjust::dna_adjust::fillSinexExample ( )

staticprivate

Here is the call graph for this function:

◆ ComputeStatistics()

void dynadjust::networkadjust::dna_adjust::ComputeStatistics ( )

private

Definition at line 8096 of file dnaadjust.cpp.

{
    // initialise potential outlier count 
    potentialOutlierCount_ = 0;
 
    // Compute adjusted measurement precisions.  If this is a staged adjustment,
    // update normals and measured-computed matrices.
    ComputeAdjustedMsrPrecisions();
 
    // Compute whole-of-network statistics.
    ComputeChiSquareNetwork();
    
    // Compute DOF and sigma zero
    ComputeGlobalNetStat();
 
    // Update Student's T statistic
    if (projectSettings_.o._adj_msr_tstat)
        ComputeTstatistics();
    
    // Compute Pelzer's reliability for whole-of-network
    ComputeGlobalPelzer();
 
    switch (projectSettings_.a.adjust_mode)
    {
    case Phased_Block_1Mode:
        return;
    }
    
    // Perform global test
    ComputeGlobalTestStat();
 
}

References ComputeAdjustedMsrPrecisions(), ComputeChiSquareNetwork(), ComputeGlobalNetStat(), ComputeGlobalPelzer(), ComputeGlobalTestStat(), ComputeTstatistics(), Phased_Block_1Mode, potentialOutlierCount_, and projectSettings_.

Referenced by fillSinexExample(), and GenerateStatistics().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeStatisticsOnIteration()

void dynadjust::networkadjust::dna_adjust::ComputeStatisticsOnIteration ( )

private

Definition at line 8215 of file dnaadjust.cpp.

{
    // Compute whole-of-network statistics.
    ComputeChiSquareNetwork();
    
    // Compute DOF and sigma zero
    ComputeGlobalNetStat();
 
    // Perform global test
    ComputeGlobalTestStat();
}

References ComputeChiSquareNetwork(), ComputeGlobalNetStat(), and ComputeGlobalTestStat().

Referenced by AdjustPhased(), AdjustSimultaneous(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeTstatistics()

void dynadjust::networkadjust::dna_adjust::ComputeTstatistics ( )

private

Definition at line 8074 of file dnaadjust.cpp.

{
    // Now that rigorous sigma zero has been computed, compute Student's T statistic
    UINT32 block;
    switch (projectSettings_.a.adjust_mode)
    {
    case PhasedMode:
        for (block=0; block<blockCount_; ++block)
        {
            // Update measurement t statistic
            UpdateMsrTstatistic(block);
 
        }
        break;
    case SimultaneousMode:
    case Phased_Block_1Mode:          // only block 1 is rigorous
        // Update measurement t statistic
        UpdateMsrTstatistic();
        break;
    }
}

References blockCount_, Phased_Block_1Mode, PhasedMode, projectSettings_, SimultaneousMode, and UpdateMsrTstatistic().

Referenced by ComputeStatistics(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMsrTstatistic()

void dynadjust::networkadjust::dna_adjust::UpdateMsrTstatistic ( const UINT32 & block = 0 )

private

Definition at line 8038 of file dnaadjust.cpp.

{
    it_vUINT32 _it_block_msr;
    it_vmsr_t _it_msr;
 
    for (_it_block_msr=v_CML_.at(block).begin(); 
        _it_block_msr!=v_CML_.at(block).end(); 
        ++_it_block_msr)
    {
        if (InitialiseandValidateMsrPointer(_it_block_msr, _it_msr))
            continue;
 
        switch (_it_msr->measType)
        {
        case 'D':   // Direction set
            // When a target direction is found, 
            // continue to next element.  
            if (_it_msr->vectorCount1 < 1)
                continue;
            UpdateMsrTstatistic_D(_it_msr);
            continue;
        case 'G':   // GPS Baseline  (treat as single-baseline cluster)
        case 'X':   // GPS Baseline cluster
        case 'Y':   // GPS Point cluster
            UpdateMsrTstatistic_GXY(_it_msr);
            continue;
        }
 
        if (fabs(sigmaZeroSqRt_ - 0.0) < PRECISION_1E10)
            _it_msr->TStat = 0.0;
        else
            _it_msr->TStat = _it_msr->NStat / sigmaZeroSqRt_;
 
    }
}

References InitialiseandValidateMsrPointer(), PRECISION_1E10(), sigmaZeroSqRt_, UpdateMsrTstatistic_D(), UpdateMsrTstatistic_GXY(), and v_CML_.

Referenced by ComputeTstatistics(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMsrTstatistic_D()

void dynadjust::networkadjust::dna_adjust::UpdateMsrTstatistic_D ( it_vmsr_t & _it_msr )

private

Definition at line 7968 of file dnaadjust.cpp.

{
    UINT32 a, angle_count(_it_msr->vectorCount2 - 1);
    UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
 
    // move to first direction record which contains the derived angles
    _it_msr++;
 
    for (a=0; a<angle_count; ++a)       // for each angle
    {
        // cater for ignored directions
        if (_it_msr->ignore)
        {
            while (skip < ignored)
            {
                skip++;
                _it_msr++;
                if (!_it_msr->ignore)
                    break;
            }
        }
 
        if (fabs(sigmaZeroSqRt_ - 0.0) < PRECISION_1E10)
            _it_msr->TStat = 0.0;
        else
            _it_msr->TStat = _it_msr->NStat / sigmaZeroSqRt_;
        _it_msr++;
    }
 
}

References PRECISION_1E10(), and sigmaZeroSqRt_.

Referenced by fillSinexExample(), and UpdateMsrTstatistic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMsrTstatistic_GXY()

void dynadjust::networkadjust::dna_adjust::UpdateMsrTstatistic_GXY ( it_vmsr_t & _it_msr )

private

Definition at line 7999 of file dnaadjust.cpp.

{
    UINT32 cluster_msr, cluster_count(_it_msr->vectorCount1);
    UINT32 covariance_count;
 
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
    {
        covariance_count = _it_msr->vectorCount2;
 
        // X measurement
        if (fabs(sigmaZeroSqRt_ - 0.0) < PRECISION_1E10)
            _it_msr->TStat = 0.0;
        else
            _it_msr->TStat = _it_msr->NStat / sigmaZeroSqRt_;
        _it_msr++;
 
        // Y measurement
        if (fabs(sigmaZeroSqRt_ - 0.0) < PRECISION_1E10)
            _it_msr->TStat = 0.0;
        else
            _it_msr->TStat = _it_msr->NStat / sigmaZeroSqRt_;
        _it_msr++;
        
 
        // Z measurement
        if (fabs(sigmaZeroSqRt_ - 0.0) < PRECISION_1E10)
            _it_msr->TStat = 0.0;
        else
            _it_msr->TStat = _it_msr->NStat / sigmaZeroSqRt_;
 
        // skip covariances until next point
        _it_msr += covariance_count * 3;
 
        if (covariance_count > 0)
            _it_msr++;
    }
}

References PRECISION_1E10(), and sigmaZeroSqRt_.

Referenced by fillSinexExample(), and UpdateMsrTstatistic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeandPrintAdjMsrOnIteration()

void dynadjust::networkadjust::dna_adjust::ComputeandPrintAdjMsrOnIteration ( )

private

Definition at line 8130 of file dnaadjust.cpp.

{
    // initialise potential outlier count 
    potentialOutlierCount_ = 0;
    bool printHeader(true);
 
    _it_uint32_u32u32_pair begin, end;
    begin = v_msr_block_.begin();
 
    // Compute and print adjusted measurements for all 
    // blocks at the end of an iteration
    for (UINT32 block(0); block<blockCount_; ++block)
    {
        if (projectSettings_.a.stage)
            DeserialiseBlockFromMappedFile(block, 4, sf_normals,
                sf_meas_minus_comp, sf_design, sf_prec_adj_msrs);
 
        // send subvector of measurements from this block
        end = begin + v_CML_.at(block).size();
        ComputeandPrintAdjMsrBlockOnIteration(block, v_uint32_u32u32_pair(begin, end), printHeader);
        begin = end;
        printHeader = false;
 
        if (projectSettings_.a.stage)
            UnloadBlock(block, 4, sf_normals,
                sf_meas_minus_comp, sf_design, sf_prec_adj_msrs);
    }
}

References blockCount_, ComputeandPrintAdjMsrBlockOnIteration(), DeserialiseBlockFromMappedFile(), potentialOutlierCount_, projectSettings_, sf_design, sf_meas_minus_comp, sf_normals, sf_prec_adj_msrs, UnloadBlock(), v_CML_, and v_msr_block_.

Referenced by AdjustPhased(), AdjustSimultaneous(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeandPrintAdjMsrBlockOnIteration()

void dynadjust::networkadjust::dna_adjust::ComputeandPrintAdjMsrBlockOnIteration	(	const UINT32 &	block,
		v_uint32_u32u32_pair	msr_block,
		bool	printHeader )

private

Definition at line 8204 of file dnaadjust.cpp.

{
    // Compute adjusted measurements
    ComputeAdjMsrBlockOnIteration(block);
    
    // Print adjusted measurements
    PrintAdjMeasurements(msr_block, printHeader);
    
}

References ComputeAdjMsrBlockOnIteration(), and PrintAdjMeasurements().

Referenced by AdjustPhasedForward(), ComputeandPrintAdjMsrOnIteration(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeAdjMsrBlockOnIteration()

void dynadjust::networkadjust::dna_adjust::ComputeAdjMsrBlockOnIteration ( const UINT32 & block )

private

Definition at line 8159 of file dnaadjust.cpp.

{
    // Compute adjusted measurement precisions (v_precAdjMsrsFull_)
    // from design and rigorous station variances 
    ComputePrecisionAdjMsrs(block);
 
    // Update measurement records and Pelzer's Global reliability
    UpdateMsrRecords(block);
 
    if (projectSettings_.a.stage)
        ComputeChiSquarePhased(block);        // This initialises chiSquared_ on each call
 
    if (projectSettings_.o._adj_msr_iteration ||
            projectSettings_.o._adj_stn_iteration ||
            projectSettings_.o._cmp_msr_iteration)
    {
        ComputeChiSquarePhased(block);        // This initialises chiSquared_ on each call
 
        switch (projectSettings_.a.adjust_mode)
        {
        case PhasedMode:
        case Phased_Block_1Mode:
            
            ComputeBlockTestStat(block);
 
            isAdjustmentQuestionable_ = (
                v_passFail_.at(block) != test_stat_pass ||
                // a much larger than expected outcome
                v_sigmaZero_.at(block) > 3.0 * v_chiSquaredUpperLimit_.at(block));
            break;
        default:
            ComputeGlobalNetStat();
            ComputeGlobalTestStat();
 
            isAdjustmentQuestionable_ = (
                // a much larger than expected outcome
                sigmaZero_ > 3.0 * chiSquaredUpperLimit_);
            break;
        }       
        
        
    }
}

References chiSquaredUpperLimit_, ComputeBlockTestStat(), ComputeChiSquarePhased(), ComputeGlobalNetStat(), ComputeGlobalTestStat(), ComputePrecisionAdjMsrs(), isAdjustmentQuestionable_, Phased_Block_1Mode, PhasedMode, projectSettings_, sigmaZero_, test_stat_pass, UpdateMsrRecords(), v_chiSquaredUpperLimit_, v_passFail_, and v_sigmaZero_.

Referenced by AdjustPhasedReverseCombine(), ComputeandPrintAdjMsrBlockOnIteration(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeAdjustedMsrPrecisions()

void dynadjust::networkadjust::dna_adjust::ComputeAdjustedMsrPrecisions ( )

private

Definition at line 7923 of file dnaadjust.cpp.

{
    // Compute adjusted measurement precisions
    UINT32 block;
    switch (projectSettings_.a.adjust_mode)
    {
    case PhasedMode:
        for (block=0; block<blockCount_; ++block)
        {
            // For staged adjustments, load block info
            if (projectSettings_.a.stage)
            {
                DeserialiseBlockFromMappedFile(block, 7,
                    sf_normals, sf_rigorous_vars, 
                    sf_design, sf_atvinv, sf_estimated_stns,
                    sf_meas_minus_comp, sf_prec_adj_msrs);
                v_normals_.at(block) = v_rigorousVariances_.at(block);
 
                FillDesignNormalMeasurementsMatrices(false, block, false);
            }
 
            // Compute adjusted measurement precisions (v_precAdjMsrsFull_)
            // from design and rigorous station variances 
            ComputePrecisionAdjMsrs(block);
 
            // Update measurement records and Pelzer's Global reliability
            UpdateMsrRecords(block);
 
            // For staged adjustments, unload all matrix data
            if (projectSettings_.a.stage)
                UnloadBlock(block);
        }
        break;
    case SimultaneousMode:
    case Phased_Block_1Mode:          // only block 1 is rigorous
        // Compute adjusted measurement precisions (v_precAdjMsrsFull_)
        // from design and rigorous station variances 
        ComputePrecisionAdjMsrs();
        
        // Update measurement records and Pelzer's Global reliability
        UpdateMsrRecords();
        break;
    }
}

References blockCount_, ComputePrecisionAdjMsrs(), DeserialiseBlockFromMappedFile(), FillDesignNormalMeasurementsMatrices(), Phased_Block_1Mode, PhasedMode, projectSettings_, sf_atvinv, sf_design, sf_estimated_stns, sf_meas_minus_comp, sf_normals, sf_prec_adj_msrs, sf_rigorous_vars, SimultaneousMode, UnloadBlock(), UpdateMsrRecords(), v_normals_, and v_rigorousVariances_.

Referenced by ComputeStatistics(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeChiSquareNetwork()

void dynadjust::networkadjust::dna_adjust::ComputeChiSquareNetwork ( )

private

Definition at line 8286 of file dnaadjust.cpp.

{
    UINT32 block;
    double chiSquared(0.);
    
    // Compute measurement statistics
    switch (projectSettings_.a.adjust_mode)
    {
    case PhasedMode:
        measurementParams_ = 0;
        for (block=0; block<blockCount_; ++block)
        {
            // For staged adjustments, load block info
            if (projectSettings_.a.stage)
                DeserialiseBlockFromMappedFile(block, 1, sf_meas_minus_comp);
 
            ComputeChiSquarePhased(block);        // This initialises chiSquared_ on each call, 
            chiSquared += chiSquared_;           // so increment a local and update chiSquared_ later
            measurementParams_ += v_measurementParams_.at(block);
 
            // For staged adjustments, unload all matrix data
            if (projectSettings_.a.stage)
                UnloadBlock(block);
        }
 
        // update global
        chiSquared_ = chiSquared;
        break;
    case Phased_Block_1Mode:                  // only block 1 is rigorous
    case SimultaneousMode:
        ComputeChiSquareSimultaneous();
        break;
    }
}

References blockCount_, chiSquared_, ComputeChiSquarePhased(), ComputeChiSquareSimultaneous(), DeserialiseBlockFromMappedFile(), measurementParams_, Phased_Block_1Mode, PhasedMode, projectSettings_, sf_meas_minus_comp, SimultaneousMode, UnloadBlock(), and v_measurementParams_.

Referenced by ComputeStatistics(), ComputeStatisticsOnIteration(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeChiSquare()

void dynadjust::networkadjust::dna_adjust::ComputeChiSquare ( const UINT32 & block )

private

Definition at line 8228 of file dnaadjust.cpp.

{
    UINT32 measurement_index(0);
 
    it_vUINT32 _it_block_msr;
    it_vmsr_t _it_msr;
 
    // Initialise chi-square
    chiSquared_ = 0.;    
 
    for (_it_block_msr=v_CML_.at(block).begin(); 
        _it_block_msr!=v_CML_.at(block).end(); 
        ++_it_block_msr)
    {
        if (InitialiseandValidateMsrPointer(_it_block_msr, _it_msr))
            continue;
 
        switch (_it_msr->measType)
        {
        case 'A':   // Horizontal angle
        case 'B':   // Geodetic azimuth
        case 'C':   // Chord dist
        case 'E':   // Ellipsoid arc
        case 'H':   // Orthometric height
        case 'I':   // Astronomic latitude
        case 'J':   // Astronomic longitude
        case 'K':   // Astronomic azimuth
        case 'L':   // Level difference
        case 'M':   // MSL arc
        case 'P':   // Geodetic latitude
        case 'Q':   // Geodetic longitude
        case 'R':   // Ellipsoidal height
        case 'S':   // Slope distance
        case 'V':   // Zenith distance
        case 'Z':   // Vertical angle
            ComputeChiSquare_ABCEHIJKLMPQRSVZ(_it_msr, measurement_index, &v_measMinusComp_.at(block));
            break;
        
        case 'D':
            // When a target direction is found, continue to next element.  
            if (_it_msr->vectorCount1 < 1)
                continue;
            ComputeChiSquare_D(_it_msr, measurement_index, &v_measMinusComp_.at(block));
            break;
        
        case 'G':   // GPS Baseline
            ComputeChiSquare_G(_it_msr, measurement_index, &v_measMinusComp_.at(block));
            break;
        
        case 'X':
        case 'Y':
            ComputeChiSquare_XY(_it_msr, measurement_index, &v_measMinusComp_.at(block));
            break;
        }
    }
}

References chiSquared_, ComputeChiSquare_ABCEHIJKLMPQRSVZ(), ComputeChiSquare_D(), ComputeChiSquare_G(), ComputeChiSquare_XY(), InitialiseandValidateMsrPointer(), v_CML_, and v_measMinusComp_.

Referenced by ComputeChiSquarePhased(), ComputeChiSquareSimultaneous(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeChiSquareSimultaneous()

void dynadjust::networkadjust::dna_adjust::ComputeChiSquareSimultaneous ( )

private

Definition at line 7829 of file dnaadjust.cpp.

{
    measurementCount_ = v_measurementCount_.at(0);
    measurementParams_ = v_measurementParams_.at(0);
 
    // Compute adjusted measurement statistics
    ComputeChiSquare(0);
}

References ComputeChiSquare(), measurementCount_, measurementParams_, v_measurementCount_, and v_measurementParams_.

Referenced by ComputeChiSquareNetwork(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeChiSquarePhased()

void dynadjust::networkadjust::dna_adjust::ComputeChiSquarePhased ( const UINT32 & block )

private

Definition at line 8322 of file dnaadjust.cpp.

{
    // Compute adjusted measurement statistics
    ComputeChiSquare(block);
}

References ComputeChiSquare().

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeChiSquareNetwork(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeTestStat()

void dynadjust::networkadjust::dna_adjust::ComputeTestStat	(	const double &	dof,
		double &	chiUpper,
		double &	chiLower,
		double &	sigmaZero,
		UINT32 &	passFail )

private

Definition at line 7851 of file dnaadjust.cpp.

{
    // Calculate limits using boost libraries
    // Confidence is halved (i.e. * 0.5) because it is a two-sided (upper and lower limit) test.
    double confidence = (100. - projectSettings_.a.confidence_interval) * 0.01;
    double conf = confidence * 0.5;
 
    try {
        // chi_squared throws when dof == 0
        boost::math::chi_squared dist(dof);
        
        chiUpper = boost::math::quantile(boost::math::complement(dist, conf)) / degreesofFreedom_;
        chiLower = boost::math::quantile(dist, conf) / degreesofFreedom_;
 
        switch (projectSettings_.a.adjust_mode)
        {
        case PhasedMode:
        case Phased_Block_1Mode:
            sigmaZero = chiSquared_ / dof;
            break;
        }
 
        // A pass is when sigma-zero is less than the chi-square upper limit.  Strictly speaking,
        // a value lower than the lower limit is not a fail.
        if (sigmaZero < chiLower)
            passFail = test_stat_warning;
        else if (sigmaZero > chiUpper)
            passFail = test_stat_fail;
        else
            passFail = test_stat_pass;
    }
    catch (const std::exception& e)
    { 
        // This is not a critical error, so don't throw an exception.  Rather,
        // just print message to output files
 
        if (projectSettings_.g.verbose > 0)
            debug_file << std::endl << "ComputeTestStat():\n     " << e.what() << std::endl;
 
        if (projectSettings_.g.verbose > 0)
            if (dof == 0)
                adj_file << std::endl << "Cannot perform chi-square test with zero degrees of freedom." << std::endl << std::endl; 
    
        passFail = test_stat_fail;
    }
}

References adj_file, chiSquared_, debug_file, degreesofFreedom_, Phased_Block_1Mode, PhasedMode, projectSettings_, test_stat_fail, test_stat_pass, and test_stat_warning.

Referenced by ComputeBlockTestStat(), ComputeGlobalTestStat(), and fillSinexExample().

Here is the caller graph for this function:

◆ ComputeBlockTestStat()

void dynadjust::networkadjust::dna_adjust::ComputeBlockTestStat ( const UINT32 & block )

private

Definition at line 7906 of file dnaadjust.cpp.

{
    UINT32 passFail(test_stat_pass);
 
    ComputeTestStat(
        v_statSummary_.at(block)._degreesofFreedom, 
        v_chiSquaredUpperLimit_.at(block), 
        v_chiSquaredLowerLimit_.at(block), 
        v_sigmaZero_.at(block), 
        passFail);
 
    // std::vector<bool> is a specialisation, and as such the value 
    // returned from at() is not a bool, but a wrapper around a value
    v_passFail_.at(block) = passFail;
}

References ComputeTestStat(), test_stat_pass, v_chiSquaredLowerLimit_, v_chiSquaredUpperLimit_, v_passFail_, v_sigmaZero_, and v_statSummary_.

Referenced by ComputeAdjMsrBlockOnIteration(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeGlobalTestStat()

void dynadjust::networkadjust::dna_adjust::ComputeGlobalTestStat ( )

private

Definition at line 7899 of file dnaadjust.cpp.

{
    ComputeTestStat(degreesofFreedom_, chiSquaredUpperLimit_, chiSquaredLowerLimit_, 
        sigmaZero_, passFail_);
}

References chiSquaredLowerLimit_, chiSquaredUpperLimit_, ComputeTestStat(), degreesofFreedom_, passFail_, and sigmaZero_.

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeStatistics(), ComputeStatisticsOnIteration(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeGlobalNetStat()

void dynadjust::networkadjust::dna_adjust::ComputeGlobalNetStat ( )

private

Definition at line 7839 of file dnaadjust.cpp.

{
    degreesofFreedom_ = measurementParams_ - unknownParams_;
    sigmaZero_ = sigmaZeroSqRt_ = 0.;
    if (degreesofFreedom_ != 0)
    {
        sigmaZero_ = chiSquared_ / degreesofFreedom_;
        sigmaZeroSqRt_ = sqrt(sigmaZero_);
    }
}

References chiSquared_, degreesofFreedom_, measurementParams_, sigmaZero_, sigmaZeroSqRt_, and unknownParams_.

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeStatistics(), ComputeStatisticsOnIteration(), and fillSinexExample().

Here is the caller graph for this function:

◆ ComputePrecisionAdjMsrs()

void dynadjust::networkadjust::dna_adjust::ComputePrecisionAdjMsrs ( const UINT32 & block = 0 )

private

Definition at line 8483 of file dnaadjust.cpp.

{
    if (projectSettings_.a.report_mode)
        return;
 
    // A*V-1*At, where:
    //   - A is design matrix
    //   - V is the inverse of the normals (i.e. precision of estimates)
    v_precAdjMsrsFull_.at(block).zero();
 
    UINT32 design_row(0);
    UINT32 precadjmsr_row(0);
    
    it_vUINT32 _it_block_msr;
    it_vmsr_t _it_msr;
 
    matrix_2d *design(&v_design_.at(block)), *aposterioriVariances(&v_normals_.at(block));
 
    // Measurements can only ever appear once in the whole CML.  That is, no one measurement will be found
    // in two or more blocks.  Therefore, unlike precisions of adjusted stations (which may appear in one
    // or more blocks), precisions of adjusted measurements are unique.
    for (_it_block_msr=v_CML_.at(block).begin(); _it_block_msr!=v_CML_.at(block).end(); ++_it_block_msr)
    {
        if (InitialiseandValidateMsrPointer(_it_block_msr, _it_msr))
            continue;
 
        // Build  At * V-1 (diagonals only as full covariances are not required)
        switch (_it_msr->measType)
        {
        case 'A':   // Horizontal angle
            ComputePrecisionAdjMsrs_A(block, 
                GetBlkMatrixElemStn1(block, &_it_msr), 
                GetBlkMatrixElemStn2(block, &_it_msr), 
                GetBlkMatrixElemStn3(block, &_it_msr),
                design, aposterioriVariances,
                design_row, precadjmsr_row);
            break;
        case 'D':   // Direction set
            // When a target direction is found, continue to next element.  
            if (_it_msr->vectorCount1 < 1)
                continue;
            ComputePrecisionAdjMsrs_D(block, _it_msr, 
                design, aposterioriVariances,
                design_row, precadjmsr_row);
            break;
        // Single station measurements
        case 'H':   // Orthometric height
        case 'I':   // Astronomic latitude
        case 'J':   // Astronomic longitude
        case 'P':   // Geodetic latitude
        case 'Q':   // Geodetic longitude
        case 'R':   // Ellipsoidal height
            ComputePrecisionAdjMsrs_HIJPQR(block,
                GetBlkMatrixElemStn1(block, &_it_msr),              
                design, aposterioriVariances,
                design_row, precadjmsr_row);
            break;
        // Two station measurements
        case 'B':   // Geodetic azimuth
        case 'C':   // Chord dist
        case 'E':   // Ellipsoid arc
        case 'K':   // Astronomic azimuth
        case 'L':   // Level difference
        case 'M':   // MSL arc
        case 'S':   // Slope distance
        case 'V':   // Zenith distance
        case 'Z':   // Vertical angle
            ComputePrecisionAdjMsrs_BCEKLMSVZ(block, 
                GetBlkMatrixElemStn1(block, &_it_msr), 
                GetBlkMatrixElemStn2(block, &_it_msr), 
                design, aposterioriVariances,
                design_row, precadjmsr_row);
            break;
        case 'G':   // GPS Baseline
        case 'X':   // GPS Baseline cluster
            ComputePrecisionAdjMsrs_GX(block, _it_msr, 
                aposterioriVariances, design_row, precadjmsr_row);
            break;
        case 'Y':   // GPS Point cluster
            ComputePrecisionAdjMsrs_Y(block, _it_msr, 
                aposterioriVariances, design_row, precadjmsr_row);
            break;      
        default:
            std::stringstream ss;
            ss << "ComputePrecisionAdjMsrs(): Unknown measurement type - '" << static_cast<std::string>(&(_it_msr->measType)) <<
                "'." << std::endl;
            SignalExceptionAdjustment(ss.str(), block);
        }
    }
}

References ComputePrecisionAdjMsrs_A(), ComputePrecisionAdjMsrs_BCEKLMSVZ(), ComputePrecisionAdjMsrs_D(), ComputePrecisionAdjMsrs_GX(), ComputePrecisionAdjMsrs_HIJPQR(), ComputePrecisionAdjMsrs_Y(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), GetBlkMatrixElemStn3(), InitialiseandValidateMsrPointer(), projectSettings_, SignalExceptionAdjustment(), v_CML_, v_design_, v_normals_, and v_precAdjMsrsFull_.

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeAdjustedMsrPrecisions(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputePrecisionAdjMsrs_A()

void dynadjust::networkadjust::dna_adjust::ComputePrecisionAdjMsrs_A	(	const UINT32 &	block,
		const UINT32 &	stn1,
		const UINT32 &	stn2,
		const UINT32 &	stn3,
		matrix_2d *	design,
		matrix_2d *	aposterioriVariances,
		UINT32 &	design_row,
		UINT32 &	precadjmsr_row )

private

Definition at line 8575 of file dnaadjust.cpp.

{
    // Horizontal angle
    double part_1[9] = {0.,0.,0.,0.,0.,0.,0.,0.,0.};
    UINT32 stations[3] = {stn1, stn2, stn3};
    UINT32 station_count(3);
    UINT32 station_i[3] = {0, 3, 6};
    UINT32 var, elem(0);
    UINT32 j, i, s;
 
    for (s=0; s<station_count; ++s) // for every station
    {
        for (i=0; i<3; ++i)     // X, Y, Z
        {
            for (j=0; j<station_count; ++j)         // for every correlated station
            {   
                var = stations[j];
                part_1[elem] += design->get(design_row, var) * aposterioriVariances->get(var, stations[s]+i);
                part_1[elem] += design->get(design_row, var+1) * aposterioriVariances->get(var+1, stations[s]+i);
                part_1[elem] += design->get(design_row, var+2) * aposterioriVariances->get(var+2, stations[s]+i);
            }
            elem++;
        }       
    }
 
    for (s=0; s<station_count; ++s)     // for every station
        for (i=0; i<3; ++i)             // X, Y, Z
            v_precAdjMsrsFull_.at(block).elementadd(precadjmsr_row, 0, part_1[station_i[s]+i] * design->get(design_row, stations[s]+i));
    
    design_row++;
    precadjmsr_row++;
}

References dynadjust::math::matrix_2d::get(), and v_precAdjMsrsFull_.

Referenced by ComputePrecisionAdjMsrs(), ComputePrecisionAdjMsrs_D(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputePrecisionAdjMsrs_D()

void dynadjust::networkadjust::dna_adjust::ComputePrecisionAdjMsrs_D	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		matrix_2d *	design,
		matrix_2d *	aposterioriVariances,
		UINT32 &	design_row,
		UINT32 &	precadjmsr_row )

private

Definition at line 8611 of file dnaadjust.cpp.

{
    UINT32 stn1, stn2, stn3;
    UINT32 a, angle_count(_it_msr->vectorCount2 - 1);     // number of directions excluding the RO
    UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
 
    for (a=0; a<angle_count; ++a)
    {
        // On the first time this loop is entered, the stn1 and stn2 will be instrument and RO
        // Then, all following directions will be instrument and target.
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr);
        stn2 = GetBlkMatrixElemStn2(block, &_it_msr);
        _it_msr++;
 
        // cater for ignored directions
        if (_it_msr->ignore)
        {
            while (skip < ignored)
            {
                skip++;
                _it_msr++;
                if (!_it_msr->ignore)
                    break;
            }
        }
 
        stn3 = GetBlkMatrixElemStn2(block, &_it_msr);
 
        ComputePrecisionAdjMsrs_A(block, stn1, stn2, stn3, 
            design, aposterioriVariances, design_row, precadjmsr_row);
    }
}

References ComputePrecisionAdjMsrs_A(), GetBlkMatrixElemStn1(), and GetBlkMatrixElemStn2().

Referenced by ComputePrecisionAdjMsrs(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputePrecisionAdjMsrs_BCEKLMSVZ()

void dynadjust::networkadjust::dna_adjust::ComputePrecisionAdjMsrs_BCEKLMSVZ	(	const UINT32 &	block,
		const UINT32 &	stn1,
		const UINT32 &	stn2,
		matrix_2d *	design,
		matrix_2d *	aposterioriVariances,
		UINT32 &	design_row,
		UINT32 &	precadjmsr_row )

private

Definition at line 8647 of file dnaadjust.cpp.

{
    // Two station measurement
    double part_1[6] = {0.,0.,0.,0.,0.,0.};
    UINT32 stations[2] = {stn1, stn2};
    UINT32 station_count(2);
    UINT32 station_i[2] = {0, 3};
    UINT32 var, elem(0);
    UINT32 j, i, s;
 
    for (s=0; s<station_count; ++s)     // for every station
    {
        for (i=0; i<3; ++i)             // X, Y, Z
        {
            for (j=0; j<station_count; ++j)         // for every correlated station
            {   
                var = stations[j];
                part_1[elem] += design->get(design_row, var) * aposterioriVariances->get(var, stations[s]+i);
                part_1[elem] += design->get(design_row, var+1) * aposterioriVariances->get(var+1, stations[s]+i);
                part_1[elem] += design->get(design_row, var+2) * aposterioriVariances->get(var+2, stations[s]+i);
            }
            elem++;
        }       
    }
 
    for (s=0; s<station_count; ++s) // for every station
        for (i=0; i<3; ++i)     // X, Y, Z
            v_precAdjMsrsFull_.at(block).elementadd(precadjmsr_row, 0, part_1[station_i[s]+i] * design->get(design_row, stations[s]+i));
    
    design_row++;
    precadjmsr_row++;
}

References dynadjust::math::matrix_2d::get(), and v_precAdjMsrsFull_.

Referenced by ComputePrecisionAdjMsrs(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputePrecisionAdjMsrs_HIJPQR()

void dynadjust::networkadjust::dna_adjust::ComputePrecisionAdjMsrs_HIJPQR	(	const UINT32 &	block,
		const UINT32 &	stn1,
		matrix_2d *	design,
		matrix_2d *	aposterioriVariances,
		UINT32 &	design_row,
		UINT32 &	precadjmsr_row )

private

Definition at line 8683 of file dnaadjust.cpp.

{
    // Single station measurement
    double part_1[3] = {0.,0.,0.};
    UINT32 i, elem;
 
    for (elem=0,i=0; i<3; ++i)      // X, Y, Z
    {   
        part_1[elem] += design->get(design_row, stn1) * aposterioriVariances->get(stn1, stn1+i);
        part_1[elem] += design->get(design_row, stn1+1) * aposterioriVariances->get(stn1+1, stn1+i);
        part_1[elem] += design->get(design_row, stn1+2) * aposterioriVariances->get(stn1+2, stn1+i);
        elem++;
    }
 
    for (i=0; i<3; ++i)             // X, Y, Z
        v_precAdjMsrsFull_.at(block).elementadd(precadjmsr_row, 0, part_1[i] * design->get(design_row, stn1+i));
    
    design_row++;
    precadjmsr_row++;
}

References dynadjust::math::matrix_2d::get(), and v_precAdjMsrsFull_.

Referenced by ComputePrecisionAdjMsrs(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputePrecisionAdjMsrs_GX()

void dynadjust::networkadjust::dna_adjust::ComputePrecisionAdjMsrs_GX	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		matrix_2d *	aposterioriVariances,
		UINT32 &	design_row,
		UINT32 &	precadjmsr_row )

private

Definition at line 8707 of file dnaadjust.cpp.

{
    UINT32 cluster_bsl, baseline_count(_it_msr->vectorCount1);
    UINT32 stn1, stn2;
    UINT32 i, j;
 
    matrix_2d precision_bsl(3, 3);
 
    for (cluster_bsl=0; cluster_bsl<baseline_count; ++cluster_bsl)
    {
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr);
        stn2 = GetBlkMatrixElemStn2(block, &_it_msr);
 
        Precision_Adjusted_GNSS_bsl<double>(*aposterioriVariances,
            stn1, stn2, &precision_bsl, false);
 
        for (i=0; i<3; ++i)
            for (j=i; j<3; ++j, ++precadjmsr_row)
                v_precAdjMsrsFull_.at(block).put(precadjmsr_row, 0, precision_bsl.get(i, j));
        
        design_row += 3;
        _it_msr += 3;
    }
}

References dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), Precision_Adjusted_GNSS_bsl(), and v_precAdjMsrsFull_.

Referenced by ComputePrecisionAdjMsrs(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputePrecisionAdjMsrs_Y()

void dynadjust::networkadjust::dna_adjust::ComputePrecisionAdjMsrs_Y	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		matrix_2d *	aposterioriVariances,
		UINT32 &	design_row,
		UINT32 &	precadjmsr_row )

private

Definition at line 8735 of file dnaadjust.cpp.

{
    UINT32 cluster_pnt, point_count(_it_msr->vectorCount1);
    UINT32 stn1, i, j;
 
    for (cluster_pnt=0; cluster_pnt<point_count; ++cluster_pnt)
    {
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr);
 
        for (i=0; i<3; ++i)
        {
            for (j=i; j<3; ++j, ++precadjmsr_row)
            {
                v_precAdjMsrsFull_.at(block).put(precadjmsr_row, 0, 
                    aposterioriVariances->get(stn1+i, stn1+j));
            }
        }
        
        design_row +=3;
        _it_msr += 3;
    }
}

References dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), and v_precAdjMsrsFull_.

Referenced by ComputePrecisionAdjMsrs(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMsrRecords()

void dynadjust::networkadjust::dna_adjust::UpdateMsrRecords ( const UINT32 & block = 0 )

private

Definition at line 8781 of file dnaadjust.cpp.

{   
    UINT32 msr_row(0), precadjmsr_row(0);
 
    it_vUINT32 _it_block_msr;
    it_vmsr_t _it_msr;
 
    for (_it_block_msr=v_CML_.at(block).begin(); 
        _it_block_msr!=v_CML_.at(block).end();    
        ++_it_block_msr)
    {
        if (InitialiseandValidateMsrPointer(_it_block_msr, _it_msr))
            continue;
 
        switch (_it_msr->measType)
        {
        case 'D':   // Direction set
            // When a target direction is found, 
            // continue to next element.  
            if (_it_msr->vectorCount1 < 1)
                continue;
            UpdateMsrRecords_D(block, _it_msr, msr_row, precadjmsr_row);
            continue;
        case 'G':   // GPS Baseline  (treat as single-baseline cluster)
        case 'X':   // GPS Baseline cluster
        case 'Y':   // GPS Point cluster
            UpdateMsrRecords_GXY(block, _it_msr, msr_row, precadjmsr_row);
            continue;
        }
 
        // Update measurement record with adjusted measurement values
        UpdateMsrRecord(block, _it_msr, msr_row++, precadjmsr_row++, _it_msr->term2);
 
    }
}

References InitialiseandValidateMsrPointer(), UpdateMsrRecord(), UpdateMsrRecords_D(), UpdateMsrRecords_GXY(), and v_CML_.

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeAdjustedMsrPrecisions(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMsrRecord()

void dynadjust::networkadjust::dna_adjust::UpdateMsrRecord	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		const UINT32 &	msr_row,
		const UINT32 &	precadjmsr_row,
		const double &	measPrec )

private

Definition at line 8885 of file dnaadjust.cpp.

{
    // set adjusted measurement correction
    _it_msr->measCorr = -v_measMinusComp_.at(block).get(msr_row, 0);
    
    // apply adjusted measurement correction
    if (_it_msr->measType == 'D')
    {
        _it_msr->measAdj = _it_msr->scale1 + _it_msr->measCorr;
        if (_it_msr->measAdj > TWO_PI)
            _it_msr->measAdj -= TWO_PI;
    }
    else
        _it_msr->measAdj = _it_msr->term1 + _it_msr->measCorr;
 
    UINT32 stn1, stn2;
    it_vstn_t_const stn1_it, stn2_it;
    matrix_2d* estimatedStations(&v_estimatedStations_.at(block));
 
    // Recompute measurements using the original types
    switch (_it_msr->measType)
    {
    case 'E':
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr); 
        stn2 = GetBlkMatrixElemStn2(block, &_it_msr);
        stn1_it = bstBinaryRecords_.begin() + _it_msr->station1;
        stn2_it = bstBinaryRecords_.begin() + _it_msr->station2;
    
        // reduce adjusted measurement to ellipsoid arc
        _it_msr->measAdj = EllipsoidChordtoEllipsoidArc<double>(
            _it_msr->measAdj,
            estimatedStations->get(stn1, 0),
            estimatedStations->get(stn1+1, 0),
            estimatedStations->get(stn1+2, 0),
            estimatedStations->get(stn2, 0),
            estimatedStations->get(stn2+1, 0),
            estimatedStations->get(stn2+2, 0),
            stn1_it->currentLatitude,
            stn1_it->currentLongitude,
            stn2_it->currentLatitude,
            datum_.GetEllipsoidRef());
        break;
    
    case 'M':
        stn1 = GetBlkMatrixElemStn1(block, &_it_msr); 
        stn2 = GetBlkMatrixElemStn2(block, &_it_msr);
        stn1_it = bstBinaryRecords_.begin() + _it_msr->station1;
        stn2_it = bstBinaryRecords_.begin() + _it_msr->station2;
    
        // reduce adjusted measurement to MSL arc
        _it_msr->measAdj = EllipsoidChordtoMSLArc<double>(
            _it_msr->measAdj,
            stn1_it->currentLatitude,
            stn2_it->currentLatitude,
            stn1_it->geoidSep,
            stn2_it->geoidSep,
            datum_.GetEllipsoidRef());
        break;
 
    // Apply N value
    case 'H':
    case 'L':
        _it_msr->measAdj -= _it_msr->preAdjCorr;
        break;
 
    // Apply correction for deflections of the vertical
    case 'A':
    case 'D':
    case 'I':
    case 'J':
    case 'K':
    case 'Z':
        // add deflection of the vertical to adjusted value
        _it_msr->measAdj += _it_msr->preAdjCorr;
        break;
    case 'V':
        // apply deflection of the vertical to the adjusted
        // measurement to get the commensurate measurement value
        _it_msr->measAdj -= _it_msr->preAdjCorr;
        break;
    }
 
    _it_msr->measAdjPrec = v_precAdjMsrsFull_.at(block).get(precadjmsr_row, 0);       // precision of adjusted measurement
    _it_msr->residualPrec = measPrec - _it_msr->measAdjPrec;                        // residual precision
 
    // Often, residualPrec contains a very small negative 
    // value, e.g. -1.5 e-35, effectively zero!
    // To circumvent errors arising from taking the square root 
    // of a negative number, first compute the absolute value.
    // While this is theoretically incorrect, the impact is of no practical
    // consequence. P. Collier
    if (_it_msr->residualPrec < 0.0)
        _it_msr->residualPrec = fabs(_it_msr->residualPrec);
 
    // Update Pelzer reliability, N-Stat, T-Stat
    UpdateMsrRecordStats(_it_msr, measPrec);
 
    if (fabs(_it_msr->NStat) > criticalValue_)
        potentialOutlierCount_++;
}

References bstBinaryRecords_, criticalValue_, datum_, EllipsoidChordtoEllipsoidArc(), EllipsoidChordtoMSLArc(), dynadjust::math::matrix_2d::get(), GetBlkMatrixElemStn1(), GetBlkMatrixElemStn2(), potentialOutlierCount_, TWO_PI(), UpdateMsrRecordStats(), v_estimatedStations_, v_measMinusComp_, and v_precAdjMsrsFull_.

Referenced by fillSinexExample(), UpdateMsrRecords(), UpdateMsrRecords_D(), and UpdateMsrRecords_GXY().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMsrRecords_D()

void dynadjust::networkadjust::dna_adjust::UpdateMsrRecords_D	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	msr_row,
		UINT32 &	precadjmsr_row )

private

Definition at line 8819 of file dnaadjust.cpp.

{
    UINT32 a, angle_count(_it_msr->vectorCount2 - 1);
    UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
 
    // move to first direction record which contains the derived angles
    _it_msr++;
    
    for (a=0; a<angle_count; ++a)       // for each angle
    {
        // cater for ignored directions
        if (_it_msr->ignore)
        {
            while (skip < ignored)
            {
                skip++;
                _it_msr++;
                if (!_it_msr->ignore)
                    break;
            }
        }
 
        UpdateMsrRecord(block, _it_msr, msr_row, precadjmsr_row, _it_msr->scale2);
        _it_msr++;
        msr_row++;
        precadjmsr_row++;
    }
}

References UpdateMsrRecord().

Referenced by fillSinexExample(), and UpdateMsrRecords().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMsrRecords_GXY()

void dynadjust::networkadjust::dna_adjust::UpdateMsrRecords_GXY	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	msr_row,
		UINT32 &	precadjmsr_row )

private

Definition at line 8850 of file dnaadjust.cpp.

{
    UINT32 cluster_msr, cluster_count(_it_msr->vectorCount1);
    UINT32 covariance_count;
    
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
    {
        covariance_count = _it_msr->vectorCount2;
 
        // X measurement
        UpdateMsrRecord(block, _it_msr, msr_row, precadjmsr_row, _it_msr->term2);
        _it_msr++;
        msr_row++;
        precadjmsr_row += 3;
 
        // Y measurement
        UpdateMsrRecord(block, _it_msr, msr_row, precadjmsr_row, _it_msr->term3);
        _it_msr++;
        msr_row++;
        precadjmsr_row += 2;
 
        // Z measurement
        UpdateMsrRecord(block, _it_msr, msr_row, precadjmsr_row, _it_msr->term4);
        msr_row++;
        precadjmsr_row++;
 
        // skip covariances until next point
        _it_msr += covariance_count * 3;
        
        if (covariance_count > 0)
            _it_msr++;
    }
}

References UpdateMsrRecord().

Referenced by fillSinexExample(), and UpdateMsrRecords().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateMsrRecordStats()

void dynadjust::networkadjust::dna_adjust::UpdateMsrRecordStats	(	it_vmsr_t &	_it_msr,
		const double &	measPrec )

private

Definition at line 8989 of file dnaadjust.cpp.

{
    _it_msr->PelzerRel = sqrt(measPrec) / sqrt(_it_msr->residualPrec);
    if (_it_msr->PelzerRel < 0. || _it_msr->PelzerRel > STABLE_LIMIT)
        _it_msr->PelzerRel = UNRELIABLE;
 
    _it_msr->NStat = _it_msr->measCorr / sqrt(_it_msr->residualPrec);
}

References STABLE_LIMIT(), and UNRELIABLE().

Referenced by fillSinexExample(), PrintAdjGNSSAlternateUnits(), and UpdateMsrRecord().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeGlobalPelzer()

void dynadjust::networkadjust::dna_adjust::ComputeGlobalPelzer ( )

private

Definition at line 9000 of file dnaadjust.cpp.

{
    UINT32 block, numMsr(0);
    double sum(0.);
 
    it_vUINT32 _it_block_msr;
    it_vmsr_t _it_msr;
 
    for (block=0; block<blockCount_; ++block)
    {
        for (_it_block_msr=v_CML_.at(block).begin(); 
            _it_block_msr!=v_CML_.at(block).end();    
            ++_it_block_msr)
        {
            if (InitialiseandValidateMsrPointer(_it_block_msr, _it_msr))
                continue;
 
            switch (_it_msr->measType)
            {
            case 'D':   // Direction set
                // When a target direction is found, continue to next element.  
                if (_it_msr->vectorCount1 < 1)
                    continue;
                ComputeGlobalPelzer_D(_it_msr, numMsr, sum);
                continue;
 
            case 'G':   // GPS Baseline (treat as single-baseline cluster)
            case 'X':   // GPS Baseline cluster
            case 'Y':   // GPS Point cluster
                ComputeGlobalPelzer_GXY(_it_msr, numMsr, sum);
                continue;
            }
            
            // All measurement types
            if (_it_msr->PelzerRel > 0. && _it_msr->PelzerRel < STABLE_LIMIT)
            {
                sum += (_it_msr->PelzerRel * _it_msr->PelzerRel - 1.);
                numMsr++;
            }
            else
                _it_msr->PelzerRel = UNRELIABLE;
        }
 
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
            break;
        }
    }
 
    // Ok, now compute Pelzer's global reliability
    if (numMsr > 0)
        globalPelzerReliability_ = sqrt(sum / numMsr);
    else
        globalPelzerReliability_  = UNRELIABLE;
 
}

References blockCount_, ComputeGlobalPelzer_D(), ComputeGlobalPelzer_GXY(), globalPelzerReliability_, InitialiseandValidateMsrPointer(), Phased_Block_1Mode, projectSettings_, STABLE_LIMIT(), UNRELIABLE(), and v_CML_.

Referenced by ComputeStatistics(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeGlobalPelzer_D()

void dynadjust::networkadjust::dna_adjust::ComputeGlobalPelzer_D	(	it_vmsr_t &	_it_msr,
		UINT32 &	numMsr,
		double &	sum )

private

Definition at line 9059 of file dnaadjust.cpp.

{
    UINT32 a, angle_count(_it_msr->vectorCount2 - 1);
    UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
 
    // move to first direction record which contains the derived angles
    _it_msr++;
    
    for (a=0; a<angle_count; ++a)       // for each angle
    {
        // cater for ignored directions
        if (_it_msr->ignore)
        {
            while (skip < ignored)
            {
                skip++;
                _it_msr++;
                if (!_it_msr->ignore)
                    break;
            }
        }
 
        if (_it_msr->PelzerRel > 0. && _it_msr->PelzerRel < UNRELIABLE)
        {
            sum += (_it_msr->PelzerRel * _it_msr->PelzerRel - 1.);
            numMsr++;
        }
        else
            _it_msr->PelzerRel = UNRELIABLE;
        _it_msr++;
    }
}

References UNRELIABLE().

Referenced by ComputeGlobalPelzer(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeGlobalPelzer_GXY()

void dynadjust::networkadjust::dna_adjust::ComputeGlobalPelzer_GXY	(	it_vmsr_t &	_it_msr,
		UINT32 &	numMsr,
		double &	sum )

private

Definition at line 9094 of file dnaadjust.cpp.

{
    UINT32 cluster_msr, cluster_count(_it_msr->vectorCount1);
    UINT32 covariance_count, i;
 
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
    {
        covariance_count = _it_msr->vectorCount2;
 
        // X, Y, Z measurement
        for (i=0; i<3; ++i)
        {
            if (_it_msr->PelzerRel > 0. && _it_msr->PelzerRel < UNRELIABLE)
            {
                sum += (_it_msr->PelzerRel * _it_msr->PelzerRel - 1.);
                numMsr++;
            }
            else
                _it_msr->PelzerRel = UNRELIABLE;
 
            if (i < 2)
                _it_msr++;
        }
 
        // skip covariances until next point
        _it_msr += covariance_count * 3;
        
        if (covariance_count > 0)
            _it_msr++;
    }
 
}

References UNRELIABLE().

Referenced by ComputeGlobalPelzer(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeChiSquare_ABCEHIJKLMPQRSVZ()

void dynadjust::networkadjust::dna_adjust::ComputeChiSquare_ABCEHIJKLMPQRSVZ	(	const it_vmsr_t &	_it_msr,
		UINT32 &	measurement_index,
		matrix_2d *	measMinusComp )

private

Definition at line 9128 of file dnaadjust.cpp.

{
    chiSquared_ +=  
        measMinusComp->get(measurement_index, 0) * 
        measMinusComp->get(measurement_index, 0) / _it_msr->term2;
 
    measurement_index++;
}

References chiSquared_, and dynadjust::math::matrix_2d::get().

Referenced by ComputeChiSquare(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeChiSquare_D()

void dynadjust::networkadjust::dna_adjust::ComputeChiSquare_D	(	it_vmsr_t &	_it_msr,
		UINT32 &	measurement_index,
		matrix_2d *	measMinusComp )

private

Definition at line 9138 of file dnaadjust.cpp.

{
    UINT32 a, angle_count(_it_msr->vectorCount2 - 1);
    UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
 
    // move to first direction record which contains the derived angles
    _it_msr++;
    
    for (a=0; a<angle_count; ++a)       // for each angle
    {
        // cater for ignored directions
        if (_it_msr->ignore)
        {
            while (skip < ignored)
            {
                skip++;
                _it_msr++;
                if (!_it_msr->ignore)
                    break;
            }
        }
 
        chiSquared_ +=
            measMinusComp->get(measurement_index, 0) * 
            measMinusComp->get(measurement_index, 0) / _it_msr->scale2;      //variance (angle)
 
        measurement_index++;
        _it_msr++;
    }
}

References chiSquared_, and dynadjust::math::matrix_2d::get().

Referenced by ComputeChiSquare(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeChiSquare_G()

void dynadjust::networkadjust::dna_adjust::ComputeChiSquare_G	(	const it_vmsr_t &	_it_msr,
		UINT32 &	measurement_index,
		matrix_2d *	measMinusComp )

private

Definition at line 9229 of file dnaadjust.cpp.

{
    matrix_2d V(3, 3);      // a-priori measurements variance matrix
    
    // 1. Form inverse variance matrix for GPS measurement
    FormInverseGPSVarianceMatrix(_it_msr, &V);
 
    // 2. Form residuals matrix
    UINT32 row, col;
    double cs(0.);
    for (row=0; row<3; ++row)
        for (col=0; col<3; ++col)
            cs += V.get(row, col) * 
                measMinusComp->get(measurement_index + row, 0) * 
                measMinusComp->get(measurement_index + col, 0);
 
    chiSquared_ += cs;
    measurement_index += 3;
}

References chiSquared_, FormInverseGPSVarianceMatrix(), and dynadjust::math::matrix_2d::get().

Referenced by ComputeChiSquare(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeChiSquare_XY()

void dynadjust::networkadjust::dna_adjust::ComputeChiSquare_XY	(	const it_vmsr_t &	_it_msr,
		UINT32 &	measurement_index,
		matrix_2d *	measMinusComp )

private

Definition at line 9250 of file dnaadjust.cpp.

{
    // compute At * Vm-1 * A
    UINT32 element_count(_it_msr->vectorCount1);
    UINT32 variance_dim(element_count * 3);
    
    matrix_2d V(variance_dim, variance_dim);        // a-priori measurements variance matrix
        
    // 1. Form inverse variance matrix for GPS measurement
    FormInverseGPSVarianceMatrix(_it_msr, &V);
 
    // 2. Form residuals matrix
    matrix_2d r(measMinusComp->submatrix(measurement_index, 0, variance_dim, 1));
    
    matrix_2d rt(r.transpose());
    matrix_2d rt_Vinv(1, variance_dim);
    matrix_2d rt_Vinv_r(1, 1);
    
    //rt_Vinv.multiply(rt, V);
    rt_Vinv.multiply(r, "T", V, "N");
 
    //rt_Vinv_r.multiply(rt_Vinv, r);
    rt_Vinv_r.multiply(rt_Vinv, "N", r, "N");
 
    chiSquared_ += rt_Vinv_r.get(0, 0);
    measurement_index += variance_dim;
}

References chiSquared_, FormInverseGPSVarianceMatrix(), dynadjust::math::matrix_2d::get(), dynadjust::math::matrix_2d::multiply(), dynadjust::math::matrix_2d::submatrix(), and dynadjust::math::matrix_2d::transpose().

Referenced by ComputeChiSquare(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FormInverseVarianceMatrix()

void dynadjust::networkadjust::dna_adjust::FormInverseVarianceMatrix	(	matrix_2d *	vmat,
		bool	LOWER_IS_CLEARED = false )

private

Definition at line 9170 of file dnaadjust.cpp.

{
    if (vmat->rows() == 1)
    {
        vmat->put(0, 0, 1./vmat->get(0, 0));
        return;
    }
    
    // As of version 3.2.0, force all inversions to use MKL.  This change
    // is enforced for two reasons:
    // 1. Sweep, Gaussian inverse and numerical recipes cholesky
    //    all require matrix data to be stored in row wise fashion, upper 
    //    triangle only, whereas contiguous matrix class stores matrix data 
    //    in column wise fashion, lower triangle.
    // 2. Sweep, Gaussian never really offered a stable solution.
    // The following switch is kept in case future development warrants
    // re-offering the option to choose (in which case, those matrix inversion
    // functions must be revised to cater for column wise, lower triangular
    // order.
 
    // TODO: All functions which load variance matrix from binary files
    // store the data in upper triangular form.  This could be changed to
    // lower triangular form, thus alleviating the need to pass 
    // LOWER_IS_CLEARED.  That is, force all operations to use a lower 
    // triangular matrix.  Not sure if this would create an efficiency or not.
    switch (projectSettings_.a.inverse_method_msr)
    {
//  case Gaussian:
//      vmat->gaussianinverse();
//      break;
//  case Sweep:
//      vmat->sweepinverse();
//      break;
    case Cholesky_mkl:
    default:
        // Inversion using Intel MKL
        vmat->cholesky_inverse(LOWER_IS_CLEARED);
        break;
    // choleskyinverse broke once the storage order of the matrix buffer was
    // changed from row-wise to column wise.
//  case Cholesky:
//  default:
        // Inversion using Numerical Recipes
//      vmat->choleskyinverse(LOWER_IS_CLEARED);
//      break;
    }
}

References dynadjust::math::matrix_2d::cholesky_inverse(), Cholesky_mkl, dynadjust::math::matrix_2d::get(), projectSettings_, dynadjust::math::matrix_2d::put(), and dynadjust::math::matrix_2d::rows().

Referenced by CarryStnEstimatesandVariancesForward(), CarryStnEstimatesandVariancesReverse(), fillSinexExample(), FormConstraintStationVarianceMatrix(), FormInverseGPSVarianceMatrix(), LoadVarianceMatrix_D(), LoadVarianceMatrix_G(), LoadVarianceMatrix_X(), LoadVarianceMatrix_Y(), Solve(), and SolveMT().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FormInverseGPSVarianceMatrix()

void dynadjust::networkadjust::dna_adjust::FormInverseGPSVarianceMatrix	(	const it_vmsr_t &	_it_msr,
		matrix_2d *	vmat )

private

Definition at line 9219 of file dnaadjust.cpp.

{
    // 1. Get upper triangular a-priori measurements variance matrix
    GetGPSVarianceMatrix<it_vmsr_t>(_it_msr, vmat);
 
    // 2. Inverse
    FormInverseVarianceMatrix(vmat, true);
}

References FormInverseVarianceMatrix(), and GetGPSVarianceMatrix().

Referenced by ComputeChiSquare_G(), ComputeChiSquare_XY(), fillSinexExample(), and FormInverseVarianceMatrixReduced().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FormInverseVarianceMatrixReduced()

bool dynadjust::networkadjust::dna_adjust::FormInverseVarianceMatrixReduced	(	it_vmsr_t	_it_msr,
		matrix_2d *	var_cart,
		const std::string &	method_name )

private

Definition at line 5196 of file dnaadjust.cpp.

{
    // Has the variance matrix already been reduced (i.e. propagated and scaled)
    if (bms_meta_.reduced)
    {
        try {
            // load as-is, assuming that an adjustment has been run
            // and the variances have been reduced (propagated and scaled)
            FormInverseGPSVarianceMatrix(_it_msr, var_cart);
            return true;
        }
        catch (const std::runtime_error& e) {
 
            // Print error message to adj file and throw exception
            std::stringstream ss;
            PrintMsrVarianceMatrixException(_it_msr, e, ss, method_name);
            SignalExceptionAdjustment(ss.str(), 0);
        }
    }
    return false;
}

References bms_meta_, FormInverseGPSVarianceMatrix(), PrintMsrVarianceMatrixException(), and SignalExceptionAdjustment().

Referenced by fillSinexExample(), LoadVarianceMatrix_G(), LoadVarianceMatrix_X(), and LoadVarianceMatrix_Y().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintStatistics()

void dynadjust::networkadjust::dna_adjust::PrintStatistics ( bool printPelzer = true )

private

Definition at line 8423 of file dnaadjust.cpp.

{
    // print statistics
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Number of unknown parameters" << std::fixed << std::setprecision(0) << unknownParams_;
    if (allStationsFixed_)
        adj_file << "  (All stations held constrained)";
    adj_file << std::endl;
 
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Number of measurements" << std::fixed << std::setprecision(0) << measurementParams_;
    if (potentialOutlierCount_ > 0)
    {
        adj_file << "  (" << potentialOutlierCount_ << " potential outlier";
        if (potentialOutlierCount_ > 1)
            adj_file << "s";
        adj_file << ")";
    }
    adj_file << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Degrees of freedom" << std::fixed << std::setprecision(0) << degreesofFreedom_ << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Chi squared" << std::fixed << std::setprecision(2) << chiSquared_ << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Rigorous Sigma Zero" << std::fixed << std::setprecision(3) << sigmaZero_ << std::endl;
    if (printPelzer)
        adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Global (Pelzer) Reliability" << std::fixed << std::setw(8) << std::setprecision(3) << globalPelzerReliability_ << 
            "(excludes non redundant measurements)" << std::endl;
    
    adj_file << std::endl;
    
    std::stringstream ss("");
    ss << "Chi-Square test (" << std::setprecision(1) << std::fixed << projectSettings_.a.confidence_interval << "%)";
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << ss.str();
    ss.str("");
    ss << std::fixed << std::setprecision(3) << 
        chiSquaredLowerLimit_ << " < " << 
        sigmaZero_ << " < " << 
        chiSquaredUpperLimit_;
    adj_file << std::setw(CHISQRLIMITS) << std::left << ss.str();
    
    ss.str("");
    if (degreesofFreedom_ < 1)
        ss << "NO REDUNDANCY";
    else
    {
        ss << "*** ";
        switch (passFail_)
        {
        case test_stat_pass: 
            ss << "PASSED";     // within upper and lower
            break;
        case test_stat_warning:
            ss << "WARNING";    // less than lower limit
            break;
        case test_stat_fail:
            ss << "FAILED";     // greater than upper limit
            break;
        }
        ss << " ***";
    }
    adj_file << std::setw(PASS_FAIL) << std::right << ss.str() << std::endl << std::endl;
}

References adj_file, allStationsFixed_, CHISQRLIMITS(), chiSquared_, chiSquaredLowerLimit_, chiSquaredUpperLimit_, degreesofFreedom_, globalPelzerReliability_, measurementParams_, PASS_FAIL(), passFail_, potentialOutlierCount_, PRINT_VAR_PAD(), projectSettings_, sigmaZero_, test_stat_fail, test_stat_pass, test_stat_warning, and unknownParams_.

Referenced by AdjustPhased(), AdjustSimultaneous(), fillSinexExample(), and GenerateStatistics().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ OpenOutputFileStreams()

void dynadjust::networkadjust::dna_adjust::OpenOutputFileStreams ( )

private

Definition at line 9279 of file dnaadjust.cpp.

{
    try {
        // Create adj file.  Throws runtime_error on failure.
        file_opener(adj_file, projectSettings_.o._adj_file);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    try {
        // Create xyz file.  Throws runtime_error on failure.
        file_opener(xyz_file, projectSettings_.o._xyz_file);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    if (projectSettings_.g.verbose > 0)
    {
        std::string debug_output_file = 
            projectSettings_.g.output_folder + FOLDER_SLASH + projectSettings_.g.network_name;
 
        switch (projectSettings_.a.adjust_mode)
        {
        case Phased_Block_1Mode:
        case PhasedMode:
 
            debug_output_file += ".phased";
 
            if (projectSettings_.a.adjust_mode == Phased_Block_1Mode)
                debug_output_file += "-block1";
            else if (projectSettings_.a.stage)
                debug_output_file += "-stage";
            else if (projectSettings_.a.multi_thread)
                debug_output_file += "-mt";
            break;
        case SimultaneousMode:
            debug_output_file += ".simult";
            break;
        }
        
        debug_output_file += ".dbg";
        
        try {
            // Create debug file.  Throws runtime_error on failure.
            file_opener(debug_file, debug_output_file);
        }
        catch (const std::runtime_error& e) {
            SignalExceptionAdjustment(e.what(), 0);
        }
    }
 
    if (projectSettings_.a.stage)
    {
        OpenStageFileStreams();
        ReserveBlockMapRegions();
    }
}

References adj_file, debug_file, file_opener(), OpenStageFileStreams(), Phased_Block_1Mode, PhasedMode, projectSettings_, ReserveBlockMapRegions(), SignalExceptionAdjustment(), SimultaneousMode, and xyz_file.

Referenced by fillSinexExample(), and PrepareAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintOutputFileHeaderInfo()

void dynadjust::networkadjust::dna_adjust::PrintOutputFileHeaderInfo ( )

private

Definition at line 9339 of file dnaadjust.cpp.

{
    // Print formatted header
    print_file_header(adj_file, "DYNADJUST ADJUSTMENT OUTPUT FILE");
    // Print formatted header
    print_file_header(xyz_file, "DYNADJUST COORDINATE OUTPUT FILE");
 
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "File name:" << boost::filesystem::system_complete(projectSettings_.o._adj_file).string() << std::endl << std::endl;
    xyz_file << std::setw(PRINT_VAR_PAD) << std::left << "File name:" << boost::filesystem::system_complete(projectSettings_.o._xyz_file).string() << std::endl << std::endl;
 
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Command line arguments: ";
    adj_file << projectSettings_.a.command_line_arguments << std::endl << std::endl;
 
    if (projectSettings_.i.input_files.empty())
    {
        adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Stations file:" << boost::filesystem::system_complete(projectSettings_.a.bst_file).string() << std::endl;
        adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Measurements file:" << boost::filesystem::system_complete(projectSettings_.a.bms_file).string() << std::endl;
    }
    else
    {
        _it_vstr _it_files(projectSettings_.i.input_files.begin());
        std::string s("Input files:");
        while (_it_files!=projectSettings_.i.input_files.end())
        {
            adj_file << std::setw(PRINT_VAR_PAD) << std::left << s << *_it_files++ << std::endl;
            s = " ";
        }
    }   
 
    // Reference frame
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Reference frame: " << datum_.GetName() << std::endl;
    xyz_file << std::setw(PRINT_VAR_PAD) << std::left << "Reference frame: " << datum_.GetName() << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Epoch: " << datum_.GetEpoch_s() << std::endl;
    xyz_file << std::setw(PRINT_VAR_PAD) << std::left << "Epoch: " << datum_.GetEpoch_s() << std::endl;
    
 
    // Geoid model
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Geoid model: " << boost::filesystem::system_complete(projectSettings_.n.ntv2_geoid_file).string() << std::endl;
    xyz_file << std::setw(PRINT_VAR_PAD) << std::left << "Geoid model: " << boost::filesystem::system_complete(projectSettings_.n.ntv2_geoid_file).string() << std::endl;
 
    
    switch (projectSettings_.a.adjust_mode)
    {
    case PhasedMode:
    case Phased_Block_1Mode:
        adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Segmentation file:" << projectSettings_.a.seg_file << std::endl;
    }
 
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Constrained Station S.D. (m):" << projectSettings_.a.fixed_std_dev << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Free Station S.D. (m):" << projectSettings_.a.free_std_dev << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Iteration threshold:" << projectSettings_.a.iteration_threshold << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Maximum iterations:" << std::setprecision(0) << std::fixed << projectSettings_.a.max_iterations << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Test confidence interval:" << std::setprecision(1) << std::fixed << projectSettings_.a.confidence_interval << "%" << std::endl;
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Uncertainties SD(e,n,up):" << std::setprecision(1) << "68.3% (1 sigma)" << std::endl;
    
    if (!projectSettings_.a.station_constraints.empty())
        adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Station constraints:" << projectSettings_.a.station_constraints << std::endl;
 
    trimstr(projectSettings_.a.comments);
 
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Station coordinate types:";
    xyz_file << std::setw(PRINT_VAR_PAD) << std::left << "Station coordinate types:";
 
    adj_file << projectSettings_.o._stn_coord_types << std::endl;
    xyz_file << projectSettings_.o._stn_coord_types << std::endl;
 
    adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Stations printed in blocks:";
    xyz_file << std::setw(PRINT_VAR_PAD) << std::left << "Stations printed in blocks:";
    if (projectSettings_.a.adjust_mode != SimultaneousMode && 
        projectSettings_.o._output_stn_blocks)
    {
        adj_file << "Yes" << std::endl;
        xyz_file << "Yes" << std::endl;
    }
    else
    {
        adj_file << "No" << std::endl;
        xyz_file << "No" << std::endl;
    }
 
    if (projectSettings_.o._stn_corr)
    {
        adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Station coordinate corrections:" <<
            "Yes" << std::endl;
        xyz_file << std::setw(PRINT_VAR_PAD) << std::left << "Station coordinate corrections:" <<
            "Yes" << std::endl;
    }
 
    if (projectSettings_.o._apply_type_b_file || projectSettings_.o._apply_type_b_global)
    {
        if (projectSettings_.o._apply_type_b_global)
        {
            adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Type B uncertainties:" <<
                projectSettings_.a.type_b_global << std::endl;
            xyz_file << std::setw(PRINT_VAR_PAD) << std::left << "Type B uncertainties:" <<
                projectSettings_.a.type_b_global << std::endl;
        }
 
        if (projectSettings_.o._apply_type_b_file)
        {
            adj_file << std::setw(PRINT_VAR_PAD) << std::left << "Type B uncertainty file:" <<
                boost::filesystem::system_complete(projectSettings_.a.type_b_file).string() << std::endl;
            xyz_file << std::setw(PRINT_VAR_PAD) << std::left << "Type B uncertainty file:" <<
                boost::filesystem::system_complete(projectSettings_.a.type_b_file).string() << std::endl;
        }
    }
 
    // Print user-supplied comments.
    // This is a bit messy and could be cleaned up.
    // Alas, the following logic is applied:
    //  - User-supplied newlines (i.e. "\n" within the string) are dealt with
    //  - Newline characters are inserted at between-word-spaces, such that the
    //    line length does not exceed PRINT_VAL_PAD
    //  - Resulting spaces at the start of a sentence on a new line are removed.
    if (!projectSettings_.a.comments.empty())
    {
        size_t s(0), t(0);
        std::string var("Comments: "), comments(projectSettings_.a.comments);
        size_t pos = 0;
 
        while (s < comments.length())
        {
            if (s + PRINT_VAL_PAD >= comments.length())
            {
                adj_file << std::setw(PRINT_VAR_PAD) << std::left << var << comments.substr(s) << std::endl; 
                break;
            }
            else
            {
                if ((pos = comments.substr(s, PRINT_VAL_PAD-1).find('\\')) != std::string::npos)
                {
                    if (comments.at(s+pos+1) == 'n')
                    {
                        adj_file << std::setw(PRINT_VAR_PAD) << std::left << var << comments.substr(s, pos) << std::endl;
                        s += pos+2;
                        if (comments.at(s) == ' ')
                            ++s;
                        var = " ";
                        continue;
                    }                   
                }
                
                t = 0;
                while (comments.at(s+PRINT_VAL_PAD - t) != ' ')
                    ++t;
                
                adj_file << std::setw(PRINT_VAR_PAD) << std::left << var << comments.substr(s, PRINT_VAL_PAD - t);
                s += PRINT_VAL_PAD - t;
                
                if (comments.at(s-1) != ' ' &&
                    comments.at(s) != ' ' &&
                    comments.at(s+1) != ' ')
                    adj_file << "-";
                else if (comments.at(s) == ' ')
                    ++s;
                adj_file << std::endl;
            }
            var = " ";
        }
    }
 
    adj_file << OUTPUTLINE << std::endl;
    xyz_file << OUTPUTLINE << std::endl;
}

References adj_file, datum_, OUTPUTLINE, Phased_Block_1Mode, PhasedMode, print_file_header(), PRINT_VAL_PAD(), PRINT_VAR_PAD(), projectSettings_, SimultaneousMode, trimstr(), and xyz_file.

Referenced by PrepareAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurements()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurements	(	const UINT32 &	block,
		const std::string &	msg = "" )

private

Definition at line 10539 of file dnaadjust.cpp.

{
    // Print header
    std::string table_heading("Computed Measurements");
    std::string col_heading("Computed");
    
    if (projectSettings_.a.adjust_mode == PhasedMode || !type.empty())
    {
        std::stringstream ss;
        ss << " (";
        if (projectSettings_.a.adjust_mode == PhasedMode)
        {
            ss << "Block " << block + 1;
            if (!type.empty())
                ss << ", ";
        }
 
        if (!type.empty())
            ss << type;
 
        ss << ")";
 
        table_heading.append(ss.str());
    }
 
    PrintAdjMeasurementsHeader(true, table_heading, 
        computedMsrs, block, false);
 
    it_vUINT32 _it_block_msr;
    it_vmsr_t _it_msr;
 
    UINT32 design_row(0);
 
    for (_it_block_msr=v_CML_.at(block).begin(); _it_block_msr!=v_CML_.at(block).end(); ++_it_block_msr)
    {
        if (InitialiseandValidateMsrPointer(_it_block_msr, _it_msr))
            continue;
 
        // When a target direction is found, continue to next element.  
        if (_it_msr->measType == 'D')
            if (_it_msr->vectorCount1 < 1)
                continue;
 
        adj_file << std::left << std::setw(PAD2) << _it_msr->measType;
 
        // normal format
        switch (_it_msr->measType)
        {
        case 'A':   // Horizontal angle
            PrintCompMeasurements_A(block, _it_msr, design_row, computedMsrs);
            break;
        case 'B':   // Geodetic azimuth
        case 'K':   // Astronomic azimuth
        case 'V':   // Zenith distance
        case 'Z':   // Vertical angle
            PrintCompMeasurements_BKVZ(block, _it_msr, design_row, computedMsrs);
            break;
        case 'C':   // Chord dist
        case 'E':   // Ellipsoid arc
        case 'L':   // Level difference
        case 'M':   // MSL arc
        case 'S':   // Slope distance
            PrintCompMeasurements_CELMS(_it_msr, design_row, computedMsrs);
            break;
        case 'D':   // Direction set
            PrintCompMeasurements_D(_it_msr, design_row);
            break;
        case 'H':   // Orthometric height
        case 'R':   // Ellipsoidal height
            PrintCompMeasurements_HR(block, _it_msr, design_row, computedMsrs);
            break;
        case 'I':   // Astronomic latitude
        case 'J':   // Astronomic longitude
        case 'P':   // Geodetic latitude
        case 'Q':   // Geodetic longitude
            PrintCompMeasurements_IJPQ(block, _it_msr, design_row, computedMsrs);
            break;
        case 'G':   // GPS Baseline (treat as single-baseline cluster)
        case 'X':   // GPS Baseline cluster
        case 'Y':   // GPS Point cluster
            PrintCompMeasurements_GXY(block, _it_msr, design_row, computedMsrs);
            break;
        }
 
    }
 
    adj_file << std::endl << std::endl;
}

References adj_file, computedMsrs, InitialiseandValidateMsrPointer(), PAD2(), PhasedMode, PrintAdjMeasurementsHeader(), PrintCompMeasurements_A(), PrintCompMeasurements_BKVZ(), PrintCompMeasurements_CELMS(), PrintCompMeasurements_D(), PrintCompMeasurements_GXY(), PrintCompMeasurements_HR(), PrintCompMeasurements_IJPQ(), projectSettings_, and v_CML_.

Referenced by AdjustPhasedForward(), AdjustSimultaneous(), and fillSinexExample().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurementsAngular()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurementsAngular	(	const char	cardinal,
		const double &	computed,
		const double &	correction,
		const it_vmsr_t &	_it_msr )

private

Definition at line 12406 of file dnaadjust.cpp.

{
    // Print computed angular measurements
    PrintMeasurementsAngular(cardinal, computed, correction, _it_msr, false);
 
    // Print measurement correction
    PrintMeasurementCorrection(cardinal, _it_msr);
 
    // Print measurement database ids
    if (projectSettings_.o._database_ids)
        PrintMeasurementDatabaseID(_it_msr);
 
    adj_file << std::endl;
}

References adj_file, PrintMeasurementCorrection(), PrintMeasurementDatabaseID(), PrintMeasurementsAngular(), and projectSettings_.

Referenced by fillSinexExample(), PrintCompMeasurements_A(), PrintCompMeasurements_BKVZ(), PrintCompMeasurements_D(), PrintCompMeasurements_IJPQ(), and PrintCompMeasurements_YLLH().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurementsLinear()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurementsLinear	(	const char	cardinal,
		const double &	computed,
		const double &	correction,
		const it_vmsr_t &	_it_msr )

private

Definition at line 12422 of file dnaadjust.cpp.

{
    // If a user wants to print apriori computed measurements, via 
    //   --output-iter-cmp-msr
    // it is likely an attempt is being made to diagnose a problematic 
    // adjustment.  For this cause, test if a linear measurement correction
    // is in the order of 1 Km
    if (!isAdjustmentQuestionable_)
        isAdjustmentQuestionable_ = (fabs(correction) > 999.9999);
 
    // Print computed linear measurements
    PrintMeasurementsLinear(cardinal, computed, correction, _it_msr, false);
 
    // Print measurement correction
    PrintMeasurementCorrection(cardinal, _it_msr);
 
    // Print measurement database ids
    if (projectSettings_.o._database_ids)
        PrintMeasurementDatabaseID(_it_msr);
 
    adj_file << std::endl;
}

References adj_file, isAdjustmentQuestionable_, PrintMeasurementCorrection(), PrintMeasurementDatabaseID(), PrintMeasurementsLinear(), and projectSettings_.

Referenced by fillSinexExample(), PrintCompMeasurements_CELMS(), PrintCompMeasurements_GXY(), PrintCompMeasurements_HR(), and PrintCompMeasurements_YLLH().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurements_A()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurements_A	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		printMeasurementsMode	printMode )

private

Definition at line 12446 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station3).stationName;
 
    double computed, correction;
    switch (printMode)
    {
    case computedMsrs:
        correction = -v_measMinusComp_.at(block).get(design_row, 0);
        computed = _it_msr->term1 + correction + _it_msr->preAdjCorr;
        break;
    case ignoredMsrs:
    default:
        correction = _it_msr->measCorr;
        computed = _it_msr->measAdj;
        break;
    }
    
    // Print angular measurement, taking care of user requirements for 
    // type, format and precision   
    PrintCompMeasurementsAngular(' ', computed, correction, _it_msr);
 
    design_row++;
}

References adj_file, bstBinaryRecords_, computedMsrs, ignoredMsrs, PrintCompMeasurementsAngular(), STATION(), and v_measMinusComp_.

Referenced by fillSinexExample(), PrintCompMeasurements(), and PrintIgnoredAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurements_CELMS()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurements_CELMS	(	it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		printMeasurementsMode	printMode )

private

Definition at line 12504 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
 
    double computed;
    switch (printMode)
    {
    case computedMsrs:
        computed = _it_msr->term1 - _it_msr->measCorr - _it_msr->preAdjCorr;
        break;
    case ignoredMsrs:
    default:
        computed = _it_msr->measAdj;
        break;
    }
    
    // Print linear measurement, taking care of user requirements for precision 
    PrintCompMeasurementsLinear(' ', computed, _it_msr->measCorr, _it_msr);
 
    design_row++;
}

References adj_file, bstBinaryRecords_, computedMsrs, ignoredMsrs, PrintCompMeasurementsLinear(), and STATION().

Referenced by fillSinexExample(), PrintCompMeasurements(), and PrintIgnoredAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurements_D()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurements_D	(	it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		bool	printIgnored = false )

private

Definition at line 12533 of file dnaadjust.cpp.

{
    UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
    
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
 
    double computed;
    
    std::string ignoreFlag(" ");
    if (_it_msr->ignore)
        ignoreFlag = "*";
 
    UINT32 angle_count;
    if (printIgnored)
        angle_count = _it_msr->vectorCount1 - 1;
    else
        angle_count = _it_msr->vectorCount2 - 1;
 
    adj_file << std::setw(PAD3) << std::left << ignoreFlag << std::setw(PAD2) << std::left << angle_count;
 
    // Print measurement database ids
    if (projectSettings_.o._database_ids)
    {
        // Measured + Computed + Correction + Meas SD + Pre Adj Corr
        UINT32 b(MSR + MSR + CORR + PREC + PACORR);
        adj_file << std::setw(b) << " ";
 
        PrintMeasurementDatabaseID(_it_msr);
    }
    adj_file << std::endl;
 
    _it_msr++;
 
    for (UINT32 a(0); a<angle_count; ++a)
    {
        // Skip over ignored directions if the direction set is not ignored.
        // If the direction set is ignored, and --output-ignored-msrs option is supplied, then
        // don't skip (i.e. continue with printing all ignored directions in the set)
        if (_it_msr->ignore && !printIgnored)
        {
            while (skip < ignored)
            {
                skip++;
                _it_msr++;
                if (!_it_msr->ignore)
                    break;
            }
        }
 
        computed = _it_msr->term1 + _it_msr->measCorr;
 
        adj_file << std::left << std::setw(PAD2) << " ";                        // measurement type
        adj_file << std::left << std::setw(STATION) << " ";                  // station1 (Instrument)
        adj_file << std::left << std::setw(STATION) << " ";                  // station2 (RO)
        adj_file << std::left << std::setw(STATION) << 
            bstBinaryRecords_.at(_it_msr->station2).stationName;   // target
        
        // Print angular measurement, taking care of user requirements for 
        // type, format and precision
        PrintCompMeasurementsAngular(' ', computed, _it_msr->measCorr, _it_msr);
        
        design_row++;
        _it_msr++;
    }
}

References adj_file, bstBinaryRecords_, CORR(), MSR(), PACORR(), PAD2(), PAD3(), PREC(), PrintCompMeasurementsAngular(), PrintMeasurementDatabaseID(), projectSettings_, and STATION().

Referenced by fillSinexExample(), PrintCompMeasurements(), and PrintIgnoredAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurements_HR()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurements_HR	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		printMeasurementsMode	printMode )

private

Definition at line 12793 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
    adj_file << std::left << std::setw(STATION) << " ";
 
    double computed, correction;
    
    switch (printMode)
    {
    case computedMsrs:
        correction = -v_measMinusComp_.at(block).get(design_row, 0);
        computed = _it_msr->term1 + correction - _it_msr->preAdjCorr;
        break;
    case ignoredMsrs:
    default:
        correction = _it_msr->measCorr;
        computed = _it_msr->measAdj;
        break;
    }
 
    // Print linear measurement, taking care of user requirements for precision 
    PrintCompMeasurementsLinear(' ', computed, correction, _it_msr);
        
    design_row++;
}

References adj_file, bstBinaryRecords_, computedMsrs, ignoredMsrs, PrintCompMeasurementsLinear(), STATION(), and v_measMinusComp_.

Referenced by fillSinexExample(), PrintCompMeasurements(), and PrintIgnoredAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurements_IJPQ()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurements_IJPQ	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		printMeasurementsMode	printMode )

private

Definition at line 12822 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
    adj_file << std::left << std::setw(STATION) << " ";
 
    double computed, correction;
    
    switch (printMode)
    {
    case computedMsrs:
        correction = -v_measMinusComp_.at(block).get(design_row, 0);
        computed = _it_msr->term1 + correction + _it_msr->preAdjCorr;
        break;
    case ignoredMsrs:
    default:
        correction = _it_msr->measCorr;
        computed = _it_msr->measAdj;
        break;
    }
 
    // Print angular measurement, taking care of user requirements for 
    // type, format and precision   
    PrintCompMeasurementsAngular(' ', computed, correction, _it_msr);
        
    design_row++;
}

References adj_file, bstBinaryRecords_, computedMsrs, ignoredMsrs, PrintCompMeasurementsAngular(), STATION(), and v_measMinusComp_.

Referenced by fillSinexExample(), PrintCompMeasurements(), and PrintIgnoredAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurements_BKVZ()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurements_BKVZ	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		printMeasurementsMode	printMode )

private

Definition at line 12475 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
 
    double computed, correction;
    switch (printMode)
    {
    case computedMsrs:
        correction = -v_measMinusComp_.at(block).get(design_row, 0);
        computed = _it_msr->term1 + correction + _it_msr->preAdjCorr;
        break;
    case ignoredMsrs:
    default:
        correction = _it_msr->measCorr;
        computed = _it_msr->measAdj;
        break;
    }
    
    // Print angular measurement, taking care of user requirements for 
    // type, format and precision   
    PrintCompMeasurementsAngular(' ', computed, correction, _it_msr);
    
    design_row++;
}

References adj_file, bstBinaryRecords_, computedMsrs, ignoredMsrs, PrintCompMeasurementsAngular(), STATION(), and v_measMinusComp_.

Referenced by fillSinexExample(), PrintCompMeasurements(), and PrintIgnoredAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurements_GXY()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurements_GXY	(	const UINT32 &	block,
		it_vmsr_t &	_it_msr,
		UINT32 &	design_row,
		printMeasurementsMode	printMode )

private

Definition at line 12684 of file dnaadjust.cpp.

{
    // Is this a Y cluster specified in latitude, longitude, height?
    if (_it_msr->measType == 'Y')
    {
        if (_it_msr->station3 == LLH_type_i)
        {
            // Print phi, lambda, H
            PrintCompMeasurements_YLLH(_it_msr, design_row);
            return;
        }
    }
 
    UINT32 cluster_msr, cluster_count(_it_msr->vectorCount1);
    UINT32 covariance_count;
    bool nextElement(false);
    double computed, correction;
 
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
    {
        if (nextElement)
            adj_file << std::left << std::setw(PAD2) << _it_msr->measType;
        else
            nextElement = true;
 
        covariance_count = _it_msr->vectorCount2;
 
        // first station
        adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
        
        // Print second station?
        switch (_it_msr->measType)
        {
        case 'G':
        case 'X':
            adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
            break;
        default:
            adj_file << std::left << std::setw(STATION) << " ";
        }
 
        // third station
        adj_file << std::left << std::setw(STATION) << " ";
 
        switch (printMode)
        {
        case computedMsrs:
            correction = -v_measMinusComp_.at(block).get(design_row, 0);
            computed = _it_msr->term1 + correction;
            break;
        case ignoredMsrs:
        default:
            correction = _it_msr->measCorr;
            computed = _it_msr->measAdj;
            break;
        }
 
        // Print linear measurement, taking care of user requirements for precision 
        PrintCompMeasurementsLinear('X', computed, correction, _it_msr);
 
        design_row++;
        _it_msr++;
    
        switch (printMode)
        {
        case computedMsrs:
            correction = -v_measMinusComp_.at(block).get(design_row, 0);
            computed = _it_msr->term1 + correction;
            break;
        case ignoredMsrs:
        default:
            correction = _it_msr->measCorr;
            computed = _it_msr->measAdj;
            break;
        }
 
        // Print linear measurement, taking care of user requirements for precision 
        PrintCompMeasurementsLinear('Y', computed, correction, _it_msr);
 
        design_row++;
        _it_msr++;
    
        switch (printMode)
        {
        case computedMsrs:
            correction = -v_measMinusComp_.at(block).get(design_row, 0);
            computed = _it_msr->term1 + correction;
            break;
        case ignoredMsrs:
        default:
            correction = _it_msr->measCorr;
            computed = _it_msr->measAdj;
            break;
        }
 
        // Print linear measurement, taking care of user requirements for precision 
        PrintCompMeasurementsLinear('Z', computed, correction, _it_msr);
 
        design_row++;
 
        // skip covariances until next point
        _it_msr += covariance_count * 3;
        
        if (covariance_count > 0)
            _it_msr++;
    }
}

References adj_file, bstBinaryRecords_, computedMsrs, ignoredMsrs, LLH_type_i, PAD2(), PrintCompMeasurements_YLLH(), PrintCompMeasurementsLinear(), STATION(), and v_measMinusComp_.

Referenced by fillSinexExample(), PrintCompMeasurements(), and PrintIgnoredAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCompMeasurements_YLLH()

void dynadjust::networkadjust::dna_adjust::PrintCompMeasurements_YLLH	(	it_vmsr_t &	_it_msr,
		UINT32 &	design_row )

private

Definition at line 12603 of file dnaadjust.cpp.

{
    // create a temporary copy of this Y measurement and transform/propagate
    // cartesian elements to geographic
    vmsr_t y_msr;
    CopyClusterMsr<vmsr_t>(bmsBinaryRecords_, _it_msr, y_msr);
    
    it_vmsr_t _it_y_msr(y_msr.begin());
    snprintf(_it_y_msr->coordType, STN_TYPE_WIDTH, "%s", LLH_type);
 
    UINT32 cluster_msr, cluster_count(_it_y_msr->vectorCount1), covariance_count;
    matrix_2d mpositions(cluster_count * 3, 1);
 
    it_vstn_t stn1_it;
    
    // 1. Convert coordinates from cartesian to geographic
    ReduceYLLHMeasurementsforPrinting(y_msr, mpositions, computedMsrs);
 
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
        design_row += 3;
 
    _it_y_msr = y_msr.begin();
 
    matrix_2d var_cart_adj(3, 3), var_geo_adj(3, 3);
 
    // 2. Convert apriori measurement precisions
 
    // Get measurement cartesian variance matrix
    matrix_2d var_cart;
    GetGPSVarianceMatrix(_it_y_msr, &var_cart);
    var_cart.filllower();
 
    // Propagate the cartesian variance matrix to geographic
    PropagateVariances_GeoCart_Cluster<double>(var_cart, &var_cart,
        mpositions, 
        datum_.GetEllipsoidRef(), 
        false);         // Cartesian -> Geographic
 
    SetGPSVarianceMatrix(_it_y_msr, var_cart);
    
    // Now print the temporary measurement
    bool nextElement(false);
 
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
    {
        stn1_it = bstBinaryRecords_.begin() + _it_y_msr->station1;
 
        if (nextElement)
            adj_file << std::left << std::setw(PAD2) << _it_y_msr->measType;
        else
            nextElement = true;
 
        covariance_count = _it_y_msr->vectorCount2;
 
        // first, second, third stations
        adj_file << std::left << std::setw(STATION) << 
            stn1_it->stationName <<
            std::left << std::setw(STATION) << " " <<        // second station
            std::left << std::setw(STATION) << " ";      // third station
 
        // Print latitude
        PrintCompMeasurementsAngular('P', _it_y_msr->measAdj, _it_y_msr->measCorr, _it_y_msr);
    
        // Print longitude
        _it_y_msr++;
        PrintCompMeasurementsAngular('L', _it_y_msr->measAdj, _it_y_msr->measCorr, _it_y_msr);
 
        // Print height
        _it_y_msr++;
        PrintCompMeasurementsLinear('H', _it_y_msr->measAdj, _it_y_msr->measCorr, _it_y_msr);
 
        // skip covariances until next point
        _it_y_msr += covariance_count * 3;
        
        if (covariance_count > 0)
            _it_y_msr++;
    }
    
}

References adj_file, bmsBinaryRecords_, bstBinaryRecords_, computedMsrs, CopyClusterMsr(), datum_, dynadjust::math::matrix_2d::filllower(), GetGPSVarianceMatrix(), LLH_type(), PAD2(), PrintCompMeasurementsAngular(), PrintCompMeasurementsLinear(), PropagateVariances_GeoCart_Cluster(), ReduceYLLHMeasurementsforPrinting(), SetGPSVarianceMatrix(), STATION(), and STN_TYPE_WIDTH().

Referenced by fillSinexExample(), and PrintCompMeasurements_GXY().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintMeasurementsAngular()

void dynadjust::networkadjust::dna_adjust::PrintMeasurementsAngular	(	const char	cardinal,
		const double &	measurement,
		const double &	correction,
		const it_vmsr_t &	_it_msr,
		bool	printAdjMsr = true )

private

Definition at line 12851 of file dnaadjust.cpp.

{
    std::string ignoreFlag(" ");
 
    double preAdjMeas(_it_msr->preAdjMeas);
    double adjMeas(measurement);
 
    switch (_it_msr->measType)
    {
    case 'D':
        // capture original direction
        preAdjMeas = _it_msr->term1;
 
        // "adjusted direction" is the original direction plus the 
        // least squares estimated angle correction.
        adjMeas = _it_msr->term1 + correction;
 
        // Don't print ignore flag for target directions
        break;
    default:
        // Print ignore flag if required
        if (_it_msr->ignore)
            ignoreFlag = "*";
        break;
    }
 
    // Is this is longitude or elevation for GNSS?
    switch (cardinal)
    {
    case 'L':       // GNSS (Y) Longitude
    case 'v':       // GNSS (alt units) Elevation
        // Change from printing whitespace for 2nd/3rd baseline station components, to
        // printing all station information
        //adj_file << std::setw(PAD2+STATION+STATION+STATION) << " ";
        
        // Measurement type
        adj_file << std::left << std::setw(PAD2) << _it_msr->measType;
        // first station
        adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
        // second station
        switch (_it_msr->measType)
        {
        case 'G':
        case 'X':
            adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
            break;
        case 'Y':
            adj_file << std::left << std::setw(STATION) << " ";
        }
        // third station
        adj_file << std::left << std::setw(STATION) << " ";
    }   
 
    adj_file << std::setw(PAD3) << std::left << ignoreFlag << std::setw(PAD2) << std::left << cardinal;
 
    double precision(0.0);
    
    // get the correct precision term
    switch (_it_msr->measType)
    {
    case 'G':
    case 'X':
    case 'Y':
        switch (cardinal)
        {
        case 'P':
        case 'a':
            precision = _it_msr->term2;     // Precision (Meas)
            break;
        case 'L':
        case 'v':
            precision = _it_msr->term3;     // Precision (Meas)
            break;
        }
        break;
    case 'D':
        // Precision of subtended angle derived from successive
        // direction set measurement precisions
        precision = _it_msr->scale2;
        break;
    default:
        precision = _it_msr->term2;     // Precision (Meas)
    }
    
    // Which angular format?
    if (projectSettings_.o._angular_type_msr == DMS)
    {       
        switch (projectSettings_.o._dms_format_msr)
        {
        case SEPARATED_WITH_SYMBOLS:
            // ddd\B0 mm' ss.sss"
            adj_file << 
                std::setw(MSR) << std::right << FormatDmsString(RadtoDms(preAdjMeas), 4+PRECISION_SEC_MSR,                   // Measured (less correction  
                    true, true) <<                                                                                  // for deflections if applied)
                std::setw(MSR) << std::right << FormatDmsString(RadtoDms(adjMeas), 4+PRECISION_SEC_MSR,                      // Adjusted
                    true, true);
            break;
        case HP_NOTATION:
            // ddd.mmssssss
            adj_file << std::setw(MSR) << std::right << StringFromT(RadtoDms(preAdjMeas), 4+PRECISION_SEC_MSR) <<                // Measured (less correction for deflections)
                std::setw(MSR) << std::right << StringFromT(RadtoDms(adjMeas), 4+PRECISION_SEC_MSR);                         // Adjusted
            break;
        case SEPARATED:
        default:
            // ddd mm ss.ssss
            adj_file << 
                std::setw(MSR) << std::right << FormatDmsString(RadtoDms(preAdjMeas), 4+PRECISION_SEC_MSR,                   // Measured (less correction  
                    true, false) <<                                                                                 // for deflections if applied)
                std::setw(MSR) << std::right << FormatDmsString(RadtoDms(adjMeas), 4+PRECISION_SEC_MSR,                      // Computed
                    true, false);
            break;
        }
 
        if (isAdjustmentQuestionable_ || (fabs(_it_msr->NStat) > criticalValue_ * 4.0))
            adj_file << 
                std::right << StringFromTW(removeNegativeZero(Seconds(correction), PRECISION_SEC_MSR), CORR, PRECISION_SEC_MSR) <<   // correction
                std::right << StringFromTW(Seconds(sqrt(precision)), PREC, PRECISION_SEC_MSR);                          // Precision (Meas)
        else
            adj_file << 
                std::setw(CORR) << std::right << StringFromT(removeNegativeZero(Seconds(correction), PRECISION_SEC_MSR), PRECISION_SEC_MSR) <<    // correction
                std::setw(PREC) << std::right << StringFromT(Seconds(sqrt(precision)), PRECISION_SEC_MSR);                   // Precision (Meas)
 
        if (printAdjMsr)
        {
            if (isAdjustmentQuestionable_ || (fabs(_it_msr->NStat) > criticalValue_ * 4.0))
                adj_file << 
                    std::right << StringFromTW(Seconds(sqrt(_it_msr->measAdjPrec)), PREC, PRECISION_SEC_MSR) <<         // Precision (Adjusted)
                    std::right << StringFromTW(Seconds(sqrt(_it_msr->residualPrec)), PREC, PRECISION_SEC_MSR);          // Precision (Residual)
            else
                adj_file << 
                    std::setw(PREC) << std::right << StringFromT(Seconds(sqrt(_it_msr->measAdjPrec)), PRECISION_SEC_MSR) <<  // Precision (Adjusted)
                    std::setw(PREC) << std::right << StringFromT(Seconds(sqrt(_it_msr->residualPrec)), PRECISION_SEC_MSR);   // Precision (Residual)
        }
    }
    else    // DDEG
    {
        // ddd.dddddddd
        //TODO - is longitude being printed?  If so, use DegreesL
        adj_file << std::setw(MSR) << std::right << StringFromT(Degrees(preAdjMeas), 4+PRECISION_SEC_MSR) <<                  // Measured (less correction for deflections)
            std::setw(MSR) << std::right << StringFromT(Degrees(adjMeas), 4+PRECISION_SEC_MSR);                               // Adjusted
        
        if (isAdjustmentQuestionable_ || (fabs(_it_msr->NStat) > criticalValue_ * 4.0))
            adj_file <<
                std::right << StringFromTW(removeNegativeZero(Degrees(correction), PRECISION_SEC_MSR), CORR, PRECISION_SEC_MSR) <<   // Correction
                std::right << StringFromTW(Degrees(sqrt(precision)), PREC, PRECISION_SEC_MSR);                          // Precision (Meas)
        else
            adj_file <<
                std::setw(CORR) << std::right << StringFromT(removeNegativeZero(Degrees(correction), PRECISION_SEC_MSR), PRECISION_SEC_MSR) <<    // Correction
                std::setw(PREC) << std::right << StringFromT(Degrees(sqrt(precision)), PRECISION_SEC_MSR);                   // Precision (Meas)
        
        if (printAdjMsr)
        {
            if (isAdjustmentQuestionable_ || (fabs(_it_msr->NStat) > criticalValue_ * 4.0))
                adj_file <<
                    std::right << StringFromTW(Degrees(sqrt(_it_msr->measAdjPrec)), PREC, PRECISION_SEC_MSR) <<         // Precision (Adjusted)
                    std::right << StringFromTW(Degrees(sqrt(_it_msr->residualPrec)), PREC, PRECISION_SEC_MSR);          // Precision (Residual)
            else
                adj_file <<
                    std::setw(PREC) << std::right << StringFromT(Degrees(sqrt(_it_msr->measAdjPrec)), PRECISION_SEC_MSR) <<  // Precision (Adjusted)
                    std::setw(PREC) << std::right << StringFromT(Degrees(sqrt(_it_msr->residualPrec)), PRECISION_SEC_MSR);   // Precision (Residual)
        }
    }
}

References adj_file, bstBinaryRecords_, CORR(), criticalValue_, Degrees(), DMS, FormatDmsString(), HP_NOTATION, isAdjustmentQuestionable_, MSR(), PAD2(), PAD3(), PREC(), PRECISION_SEC_MSR, projectSettings_, RadtoDms(), removeNegativeZero(), Seconds(), SEPARATED, SEPARATED_WITH_SYMBOLS, STATION(), StringFromT(), and StringFromTW().

Referenced by fillSinexExample(), PrintAdjMeasurementsAngular(), and PrintCompMeasurementsAngular().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintMeasurementsLinear()

void dynadjust::networkadjust::dna_adjust::PrintMeasurementsLinear	(	const char	cardinal,
		const double &	measurement,
		const double &	correction,
		const it_vmsr_t &	_it_msr,
		bool	printAdjMsr = true )

private

Definition at line 13036 of file dnaadjust.cpp.

{
    std::string ignoreFlag(" ");
    if (_it_msr->ignore)
        ignoreFlag = "*";
 
    switch (cardinal)
    {
    case 'Y':
    case 'Z':
    case 'H':
    case 'n':
    case 'u':
    case 's':
        // Change from printing whitespace for 2nd/3rd baseline station components, to
        // printing all station information
        //adj_file << std::setw(PAD2+STATION+STATION+STATION) << " ";
 
        // Measurement type
        adj_file << std::left << std::setw(PAD2) << _it_msr->measType;
        // first station
        adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
        // second station
        switch (_it_msr->measType)
        {
        case 'G':
        case 'X':
            adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
            break;
        case 'Y':
            adj_file << std::left << std::setw(STATION) << " ";
        }
        // third station
        adj_file << std::left << std::setw(STATION) << " ";
    }
    
    adj_file << std::setw(PAD3) << std::left << ignoreFlag << std::setw(PAD2) << std::left << cardinal <<               // If GPS, then 'X', 'Y' or 'Z', else ' '
        std::setw(MSR) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << _it_msr->preAdjMeas <<    // Measured (less correction for geoid)
        std::setw(MSR) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << measurement;              // Adjusted
    
    if (isAdjustmentQuestionable_ || (fabs(_it_msr->NStat) > criticalValue_ * 4.0))
        adj_file <<         
            std::right << StringFromTW(removeNegativeZero(correction, PRECISION_MTR_MSR), CORR, PRECISION_MTR_MSR); // Correction
    else
        adj_file <<         
            std::setw(CORR) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << 
            removeNegativeZero(correction, PRECISION_MTR_MSR);                                       // Correction
 
    // print the correct precision term
    switch (_it_msr->measType)
    {
    case 'G':
    case 'X':
    case 'Y':
        switch (cardinal)
        {
        case 'X':       // XYZ
        case 'e':       // ENU
            adj_file << std::setw(PREC) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << sqrt(_it_msr->term2);       // Precision (Meas)
            break;
        case 'Y':       // XYZ
        case 'n':       // ENU
            adj_file << std::setw(PREC) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << sqrt(_it_msr->term3);       // Precision (Meas)
            break;
        case 'Z':       // XYZ
        case 'u':       // ENU
        case 'H':       // LLH (Lat and Lon cardinals are printed in PrintMeasurementsAngular)
            adj_file << std::setw(PREC) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << sqrt(_it_msr->term4);       // Precision (Meas)
            break;
        case 's':       // AED (Azimuth and vertical angle cardinals are printed in PrintMeasurementsAngular)
            switch (projectSettings_.o._adj_gnss_units)
            {
            case AED_adj_gnss_ui:
                adj_file << std::setw(PREC) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << sqrt(_it_msr->term4);   // Precision (Meas)
                break;
            case ADU_adj_gnss_ui:
                adj_file << std::setw(PREC) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << sqrt(_it_msr->term3);   // Precision (Meas)
                break;
            }
            break;
        }
        break;
    default:
        if (isAdjustmentQuestionable_ || (fabs(_it_msr->NStat) > criticalValue_ * 4.0))
            adj_file << StringFromTW(sqrt(_it_msr->term2), PREC, PRECISION_MTR_MSR);               // Precision (Meas)
        else
            adj_file << std::setw(PREC) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << sqrt(_it_msr->term2);           // Precision (Meas)
    }
 
    if (printAdjMsr)
    {
        if (isAdjustmentQuestionable_ || (fabs(_it_msr->NStat) > criticalValue_ * 4.0))
            adj_file << 
                std::right << StringFromTW(sqrt(_it_msr->measAdjPrec), PREC, PRECISION_MTR_MSR) <<     // Precision (Adjusted)
                std::right << StringFromTW(sqrt(_it_msr->residualPrec), PREC, PRECISION_MTR_MSR);      // Precision (Residual)
        else
            adj_file << std::setw(PREC) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << sqrt(_it_msr->measAdjPrec) <<   // Precision (Adjusted)
                std::setw(PREC) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << sqrt(_it_msr->residualPrec);            // Precision (Residual)
    }
}

References adj_file, ADU_adj_gnss_ui, AED_adj_gnss_ui, bstBinaryRecords_, CORR(), criticalValue_, isAdjustmentQuestionable_, MSR(), PAD2(), PAD3(), PREC(), PRECISION_MTR_MSR, projectSettings_, removeNegativeZero(), STATION(), and StringFromTW().

Referenced by fillSinexExample(), PrintAdjMeasurementsLinear(), and PrintCompMeasurementsLinear().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintMeasurementCorrection()

void dynadjust::networkadjust::dna_adjust::PrintMeasurementCorrection	(	const char	cardinal,
		const it_vmsr_t &	_it_msr )

private

Definition at line 13142 of file dnaadjust.cpp.

{
    switch (_it_msr->measType)
    {
    case 'A':
    case 'B':
    case 'D':
    case 'I':
    case 'J':
    case 'K':
    case 'P':
    case 'Q':
    case 'V':
    case 'Z':
        // Pre adjustment correction for deflections
        adj_file << std::setw(PACORR) << std::setprecision(PRECISION_SEC_MSR) << std::fixed << std::right << 
            removeNegativeZero(Seconds(_it_msr->preAdjCorr), PRECISION_SEC_MSR);
        break;
    case 'Y':
        // Pre adjustment correction of N-value on GPS applies to H cardinal of Y clusters in
        // geographic format only!
        switch (cardinal)
        {
        case 'H':           
            adj_file << std::setw(PACORR) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << 
                removeNegativeZero(_it_msr->preAdjCorr, PRECISION_MTR_MSR);
            break;
        case 'P':
        case 'L':
            adj_file << std::setw(PACORR) << std::setprecision(PRECISION_SEC_MSR) << std::fixed << std::right << 0.0;
            break;
        default:    // X, Y, Z
            adj_file << std::setw(PACORR) << std::setprecision(PRECISION_MTR_MSR) << std::fixed << std::right << 0.0;
            break;
        }
        break;
    case 'C':
    case 'E':
    case 'H':
    case 'L':
    case 'M':
    case 'S':
    case 'G':
    case 'X':
    default:
        // Pre adjustment correction for N-value or reductions from MSL/ellipsoid arcs
        adj_file << std::setw(PACORR) << std::setprecision(PRECISION_SEC_MSR) << std::fixed << std::right << 
            removeNegativeZero(_it_msr->preAdjCorr, PRECISION_SEC_MSR);
        break;
    }
 
    
}

References adj_file, PACORR(), PRECISION_MTR_MSR, PRECISION_SEC_MSR, removeNegativeZero(), and Seconds().

Referenced by fillSinexExample(), PrintAdjMeasurementStatistics(), PrintCompMeasurementsAngular(), and PrintCompMeasurementsLinear().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintMeasurementDatabaseID()

void dynadjust::networkadjust::dna_adjust::PrintMeasurementDatabaseID	(	const it_vmsr_t &	_it_msr,
		bool	initialise_dbindex = true )

private

Definition at line 13196 of file dnaadjust.cpp.

{
    // set iterator to the database index
    if (initialise_dbindex)
    {
        size_t dbindx = std::distance(bmsBinaryRecords_.begin(), _it_msr);
        _it_dbid = v_msr_db_map_.begin() + dbindx;
    }
 
    // Print measurement id
    if (_it_dbid->is_msr_id_set)
        adj_file << std::setw(STDDEV) << std::right << _it_dbid->msr_id;
    else
        adj_file << std::setw(STDDEV) << " ";
 
    // Print cluster id?
    switch (_it_msr->measType)
    {
    case 'D':
    case 'G':
    case 'X':
    case 'Y':
        if (_it_dbid->is_cls_id_set)
            adj_file << std::setw(STDDEV) << std::right << _it_dbid->cluster_id;
        else
            adj_file << std::setw(STDDEV) << " ";
    }
}

References _it_dbid, adj_file, bmsBinaryRecords_, STDDEV(), and v_msr_db_map_.

Referenced by fillSinexExample(), PrintAdjMeasurements_D(), PrintAdjMeasurementStatistics(), PrintCompMeasurements_D(), PrintCompMeasurementsAngular(), and PrintCompMeasurementsLinear().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FormUniqueMsrList()

void dynadjust::networkadjust::dna_adjust::FormUniqueMsrList ( )

private

Definition at line 3113 of file dnaadjust.cpp.

{
    // Determine actual CML size
    size_t cml_size(0);
    for_each(v_CML_.begin(), v_CML_.end(),
        [&cml_size](vUINT32& blockCML){
            cml_size += blockCML.size();
    });
 
    UINT32 block(0);
    it_vvUINT32 _it_cml;
    it_vUINT32 _it_block_msr;
    
    v_msr_block_.clear();
    v_msr_block_.reserve(cml_size);
    
    // Fill vector of msr-block pairs
    for (_it_cml=v_CML_.begin(); _it_cml!=v_CML_.end(); ++_it_cml, ++block)
        for (_it_block_msr=_it_cml->begin(); _it_block_msr!=_it_cml->end(); ++_it_block_msr)
            v_msr_block_.push_back(
                uint32_u32u32_pair(*_it_block_msr,        // msr index
                    uint32_uint32_pair(block, 0)));       // block, precision adj msr row
 
    // Is the index to the first row of the precision of adjusted measurements vector needed?
    if (projectSettings_.o._adj_gnss_units == XYZ_adj_gnss_ui)
        return;
 
    it_vmsr_t _it_msr;
    _it_uint32_u32u32_pair _it_b_pam;
    UINT32 precadjmsr_row(0);
    block = UINT_MAX;
 
    for (_it_b_pam=v_msr_block_.begin(); _it_b_pam!=v_msr_block_.end(); ++_it_b_pam)
    {   
        // new block?  Initialise row counter to the first row
        if (block != _it_b_pam->second.first)
        {
            precadjmsr_row = 0;
            block = _it_b_pam->second.first;
        }
        
        // Set index
        _it_b_pam->second.second = precadjmsr_row;
 
        // Get the next measurement and determine how many rows until the next index
        _it_msr = bmsBinaryRecords_.begin() + (_it_b_pam->first);
 
        switch (_it_msr->measType)
        {
        // Single row measurements
        case 'A':
        case 'B':   // Geodetic azimuth
        case 'C':   // Chord dist
        case 'E':   // Ellipsoid arc
        case 'K':   // Astronomic azimuth
        case 'L':   // Level difference
        case 'M':   // MSL arc
        case 'S':   // Slope distance
        case 'V':   // Zenith distance
        case 'Z':   // Vertical angle
        case 'H':   // Orthometric height
        case 'I':   // Astronomic latitude
        case 'J':   // Astronomic longitude
        case 'P':   // Geodetic latitude
        case 'Q':   // Geodetic longitude
        case 'R':   // Ellipsoidal height
            precadjmsr_row++;
            break;
        // Single row per subtended angle (# directions less 1)
        case 'D':   // Direction set
            precadjmsr_row += (_it_msr->vectorCount2 - 1);
            break;
        // Three rows (6 elements for upper triangular)
        case 'G':   // GPS Baseline
            precadjmsr_row += 6;
            break;
        // Three rows (6 elements for upper triangular) per
        // cluster measurement
        case 'X':   // GPS Baseline cluster
        case 'Y':   // GPS Point cluster
            precadjmsr_row += _it_msr->vectorCount1 * 6;
            break;
        }
        
    }
 
}

References bmsBinaryRecords_, projectSettings_, v_CML_, v_msr_block_, and XYZ_adj_gnss_ui.

Referenced by fillSinexExample(), and PrepareAdjustment().

Here is the caller graph for this function:

◆ PrintAdjMeasurementsHeader()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurementsHeader	(	bool	printHeader,
		const std::string &	table_heading,
		printMeasurementsMode	printMode,
		UINT32	block,
		bool	printBlocks = false )

private

Definition at line 10629 of file dnaadjust.cpp.

{
    if (printHeader)
        adj_file << std::endl << table_heading << std::endl <<
        "------------------------------------------" << std::endl << std::endl;
 
    if (printBlocks)
    {
        switch (projectSettings_.a.adjust_mode)
        {
        case PhasedMode:
        case Phased_Block_1Mode:
            if (projectSettings_.o._output_msr_blocks)
                adj_file << "Block " << block << std::endl;
            break;
        }
    }
 
    std::string col1_heading, col2_heading;
 
    // determine headings
    switch (printMode)
    {
    case ignoredMsrs:
    case computedMsrs:
        col1_heading = "Computed";
        col2_heading = "Difference";
        break;
    case adjustedMsrs:
        col1_heading = "Adjusted";
        col2_heading = "Correction";
        break;
    }
    
    // print header
 
    // Adjusted, computed and ignored measurements
    UINT32 j(PAD2 + STATION + STATION + STATION);
    adj_file <<
        std::setw(PAD2) << std::left << "M" << 
        std::setw(STATION) << std::left << "Station 1" << 
        std::setw(STATION) << std::left << "Station 2" << 
        std::setw(STATION) << std::left << "Station 3";
 
    // Adjusted, computed and ignored measurements
    j += PAD3 + PAD3 + MSR + MSR + CORR + PREC;
    adj_file <<
        std::setw(PAD3) << std::left << "*" <<
        std::setw(PAD2) << std::left << "C" <<
        std::setw(MSR) << std::right << "Measured" <<
        std::setw(MSR) << std::right << col1_heading <<  // Computed or Adjusted
        std::setw(CORR) << std::right << col2_heading <<    // Difference or Correction
        std::setw(PREC) << std::right << "Meas. SD";
    
    // Adjusted measurements only
    switch (printMode)
    {
    case adjustedMsrs:
        j += PREC + PREC + STAT;
        adj_file <<
            std::setw(PREC) << std::right << "Adj. SD" <<
            std::setw(PREC) << std::right << "Corr. SD" <<
            std::setw(STAT) << std::right << "N-stat";
 
        // print t-statistics?
        if (projectSettings_.o._adj_msr_tstat)
        {
            j += STAT;
            adj_file << std::setw(STAT) << std::right << "T-stat";          
        }
 
        j += REL;
        adj_file <<
            std::setw(REL) << std::right << "Pelzer Rel";
        break;
    default:
        break;
    }
    
    // Adjusted, computed and ignored measurements
    j += PACORR;
    adj_file <<
        std::setw(PACORR) << std::right << "Pre Adj Corr";
 
    // Adjusted measurements only
    switch (printMode)
    {
    case adjustedMsrs:
        j += OUTLIER;
        adj_file <<
            std::setw(OUTLIER) << std::right << "Outlier?";
        break;
    default:
        break;
    }
 
    // Adjusted, computed and ignored measurements
    // Print database ids?
    if (projectSettings_.o._database_ids)
    {
        j += STDDEV + STDDEV;
        adj_file << 
            std::setw(STDDEV) << std::right << "Meas. ID" << 
            std::setw(STDDEV) << std::right << "Clust. ID";
    }
 
    adj_file << std::endl;
 
    UINT32 i;
    for (i=0; i<j; ++i)
        adj_file << "-";
 
    adj_file << std::endl;
}

References adj_file, adjustedMsrs, computedMsrs, CORR(), ignoredMsrs, MSR(), OUTLIER(), PACORR(), PAD2(), PAD3(), Phased_Block_1Mode, PhasedMode, PREC(), projectSettings_, REL(), STAT(), STATION(), and STDDEV().

Referenced by fillSinexExample(), PrintAdjMeasurements(), PrintCompMeasurements(), and PrintIgnoredAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurements()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurements	(	v_uint32_u32u32_pair	msr_block,
		bool	printHeader )

private

Definition at line 12226 of file dnaadjust.cpp.

{
    // Print heading
    std::string table_heading("Adjusted Measurements");
 
    if (projectSettings_.o._adj_msr_iteration)
    {
        std::stringstream ss;
        if (projectSettings_.a.adjust_mode == PhasedMode && forward_)
        {
            UINT32 block = msr_block.at(0).second.first;
            ss << " (Block " << msr_block.at(0).second.first + 1 << ", ";
            if (v_blockMeta_.at(block)._blockLast || v_blockMeta_.at(block)._blockIsolated)
                ss << "rigorous)";
            else
                ss << "in isolation)";
            table_heading.append(ss.str());
        }
        else if (projectSettings_.a.adjust_mode == PhasedMode && isIterationComplete_)
        {
            ss << " (Iteration " << CurrentIteration() << ")";
            table_heading.append(ss.str());
        }
    }
 
    PrintAdjMeasurementsHeader(printHeader, table_heading,
        adjustedMsrs, msr_block.at(0).second.first + 1, true);
        
    _it_uint32_u32u32_pair _it_block_msr;
    it_vmsr_t _it_msr;
 
    try {
        // Should the adjusted measurements be sorted?
        switch (projectSettings_.o._sort_adj_msr)
        {
        case type_adj_msr_sort_ui:
            SortMeasurementsbyType(msr_block);
            break;
        case inst_adj_msr_sort_ui:
            SortMeasurementsbyToStn(msr_block);
            break;
        case targ_adj_msr_sort_ui:
            SortMeasurementsbyFromStn(msr_block);
            break;
        case meas_adj_msr_sort_ui:
            SortMeasurementsbyValue(msr_block);
            break;
        case corr_adj_msr_sort_ui:
            SortMeasurementsbyResidual(msr_block);
            break;
        case a_sd_adj_msr_sort_ui:
            SortMeasurementsbyAdjSD(msr_block);
            break;
        case n_st_adj_msr_sort_ui:
            SortMeasurementsbyNstat(msr_block);
            break;
        case orig_adj_msr_sort_ui:
        default:
            std::sort(msr_block.begin(), msr_block.end());
            break;
        }
    }
    catch (...) {
        std::stringstream ss;
        ss << "Failed to sort measurements according to the ";
 
        switch (projectSettings_.o._sort_adj_msr)
        {
        case orig_adj_msr_sort_ui:
            ss << "original file order";
            break;
        case type_adj_msr_sort_ui:
            ss << "measurement type";
            break;
        case inst_adj_msr_sort_ui:
            ss << "first measurement station";
            break;
        case targ_adj_msr_sort_ui:
            ss << "second measurement station";         
            break;
        case meas_adj_msr_sort_ui:
            ss << "measurement value";
            break;
        case corr_adj_msr_sort_ui:
            ss << "measurement correction";
            break;
        case a_sd_adj_msr_sort_ui:
            ss << "adjusted measurement standard deviation";
            break;
        case n_st_adj_msr_sort_ui:
            ss << "measurement n-statistic";
            break;
        }
            
 
        ss << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    UINT32 clusterID(MAX_UINT32_VALUE);
 
    for (_it_block_msr=msr_block.begin(); _it_block_msr!=msr_block.end(); ++_it_block_msr)
    {
        _it_msr = bmsBinaryRecords_.begin() + (_it_block_msr->first);
        
        // When a non-measurement element is found (i.e. Y or Z or covariance component),
        // continue to next element.  Hence, only pointers to the starting element of each
        // measurement are kept. See declaration of measRecord.measStart for more info.
        if (_it_msr->measStart != xMeas)
            continue;
 
        // When a target direction is found, continue to next element.  
        if (_it_msr->measType == 'D')
            if (_it_msr->vectorCount1 < 1)
                continue;
 
        // For cluster measurements, only print measurement type if
        // this measurement is from a new cluster
        switch (_it_msr->measType)
        {
        case 'D':   // Direction set
        case 'X':   // GPS Baseline cluster
        case 'Y':   // GPS Point cluster
            if (_it_msr->clusterID != clusterID)
            {
                adj_file << std::left << std::setw(PAD2) << _it_msr->measType;
                clusterID = _it_msr->clusterID;
            }
            else
                adj_file << "  ";
            break;
        default:
            adj_file << std::left << std::setw(PAD2) << _it_msr->measType;
        }
 
        // normal format
        switch (_it_msr->measType)
        {
        case 'A':   // Horizontal angle
            PrintAdjMeasurements_A(_it_msr);
            break;
        case 'B':   // Geodetic azimuth
        case 'K':   // Astronomic azimuth
        case 'V':   // Zenith distance
        case 'Z':   // Vertical angle
            PrintAdjMeasurements_BKVZ(_it_msr);
            break;
        case 'C':   // Chord dist
        case 'E':   // Ellipsoid arc
        case 'L':   // Level difference
        case 'M':   // MSL arc
        case 'S':   // Slope distance
            PrintAdjMeasurements_CELMS(_it_msr);
            break;
        case 'D':   // Direction set
            PrintAdjMeasurements_D(_it_msr);
            break;
        case 'H':   // Orthometric height
        case 'R':   // Ellipsoidal height
            PrintAdjMeasurements_HR(_it_msr);
            break;
        case 'I':   // Astronomic latitude
        case 'J':   // Astronomic longitude
        case 'P':   // Geodetic latitude
        case 'Q':   // Geodetic longitude
            PrintAdjMeasurements_IJPQ(_it_msr);
            break;
        case 'G':   // GPS Baseline (treat as single-baseline cluster)
        case 'X':   // GPS Baseline cluster
        case 'Y':   // GPS Point cluster
            PrintAdjMeasurements_GXY(_it_msr, _it_block_msr->second);
            break;
        }
 
    }
    
    adj_file << std::endl;
}

References a_sd_adj_msr_sort_ui, adj_file, adjustedMsrs, bmsBinaryRecords_, corr_adj_msr_sort_ui, CurrentIteration(), forward_, inst_adj_msr_sort_ui, isIterationComplete_, MAX_UINT32_VALUE(), meas_adj_msr_sort_ui, n_st_adj_msr_sort_ui, orig_adj_msr_sort_ui, PAD2(), PhasedMode, PrintAdjMeasurements_A(), PrintAdjMeasurements_BKVZ(), PrintAdjMeasurements_CELMS(), PrintAdjMeasurements_D(), PrintAdjMeasurements_GXY(), PrintAdjMeasurements_HR(), PrintAdjMeasurements_IJPQ(), PrintAdjMeasurementsHeader(), projectSettings_, SignalExceptionAdjustment(), SortMeasurementsbyAdjSD(), SortMeasurementsbyFromStn(), SortMeasurementsbyNstat(), SortMeasurementsbyResidual(), SortMeasurementsbyToStn(), SortMeasurementsbyType(), SortMeasurementsbyValue(), targ_adj_msr_sort_ui, type_adj_msr_sort_ui, v_blockMeta_, and xMeas.

Referenced by ComputeandPrintAdjMsrBlockOnIteration(), fillSinexExample(), and PrintAdjustedNetworkMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurementsAngular()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurementsAngular	(	const char	cardinal,
		const it_vmsr_t &	_it_msr,
		bool	initialise_dbindex = true )

private

Definition at line 13016 of file dnaadjust.cpp.

{
    // Print adjusted angular measurements
    PrintMeasurementsAngular(cardinal, _it_msr->measAdj, _it_msr->measCorr, _it_msr);
 
    // Print adjusted statistics
    PrintAdjMeasurementStatistics(cardinal, _it_msr, initialise_dbindex);
}

References PrintAdjMeasurementStatistics(), and PrintMeasurementsAngular().

Referenced by fillSinexExample(), PrintAdjGNSSAlternateUnits(), PrintAdjMeasurements_A(), PrintAdjMeasurements_BKVZ(), PrintAdjMeasurements_D(), PrintAdjMeasurements_IJPQ(), and PrintAdjMeasurements_YLLH().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurementsLinear()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurementsLinear	(	const char	cardinal,
		const it_vmsr_t &	_it_msr,
		bool	initialise_dbindex = true )

private

Definition at line 13026 of file dnaadjust.cpp.

{
    // Print adjusted linear measurements
    PrintMeasurementsLinear(cardinal, _it_msr->measAdj, _it_msr->measCorr, _it_msr);
    
    // Print adjusted statistics
    PrintAdjMeasurementStatistics(cardinal, _it_msr, initialise_dbindex);
}

References PrintAdjMeasurementStatistics(), and PrintMeasurementsLinear().

Referenced by fillSinexExample(), PrintAdjGNSSAlternateUnits(), PrintAdjMeasurements_CELMS(), PrintAdjMeasurements_GXY(), PrintAdjMeasurements_HR(), and PrintAdjMeasurements_YLLH().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjGNSSAlternateUnits()

void dynadjust::networkadjust::dna_adjust::PrintAdjGNSSAlternateUnits	(	it_vmsr_t &	_it_msr,
		const uint32_uint32_pair &	b_pam )

private

Definition at line 13656 of file dnaadjust.cpp.

{
    // Create copy of _it_msr, transform, then send to PrintAdjMeasurementsLinear
    vmsr_t gnss_msr;
    // vector components (original and adjusted)
    matrix_2d gnss_cart(3, 1), gnss_local(3, 1);
    matrix_2d gnss_adj_cart(3, 1), gnss_adj_local(3, 1);
    // variance components (original and adjusted)
    matrix_2d var_cart(3, 3), var_local(3, 3), var_polar(3, 3);
    matrix_2d var_adj_local(3, 3), var_adj_polar(3, 3);
 
    // For staged adjustments, load precision of adjusted measurements
    if (projectSettings_.a.stage)
        DeserialiseBlockFromMappedFile(b_pam.first, 1, sf_prec_adj_msrs);
 
    // get precision of adjusted measurements
    double lower_mtx_buffer[6];
    memcpy(lower_mtx_buffer, v_precAdjMsrsFull_.at(b_pam.first).getbuffer(b_pam.second, 0), sizeof(lower_mtx_buffer));
    matrix_2d var_adj_cart(3, 3, lower_mtx_buffer, 6, mtx_lower);
    var_adj_cart.fillupper();
 
    if (projectSettings_.a.stage)
        // For staged adjustments, unload precision of adjusted measurements
        UnloadBlock(b_pam.first, 1, sf_prec_adj_msrs);
    
    // Get X
    gnss_msr.push_back(*_it_msr);
    gnss_cart.put(0, 0, _it_msr->term1);
    gnss_adj_cart.put(0, 0, _it_msr->measAdj);
 
    var_cart.put(0, 0, _it_msr->term2);
    
    // Get Y
    _it_msr++;
    gnss_msr.push_back(*_it_msr);
    gnss_cart.put(1, 0, _it_msr->term1);
    gnss_adj_cart.put(1, 0, _it_msr->measAdj);
 
    var_cart.put(0, 1, _it_msr->term2);
    var_cart.put(1, 1, _it_msr->term3);
    
    // Get Z
    _it_msr++;
    gnss_msr.push_back(*_it_msr);
    gnss_cart.put(2, 0, _it_msr->term1);
    gnss_adj_cart.put(2, 0, _it_msr->measAdj);
 
    var_cart.put(0, 2, _it_msr->term2);
    var_cart.put(1, 2, _it_msr->term3);
    var_cart.put(2, 2, _it_msr->term4);
 
    it_vmsr_t _it_gnss_msr(gnss_msr.begin());
 
    var_cart.filllower();
 
    double azimuth, elevation, distance;
    double azimuthAdj, elevationAdj, distanceAdj;
    double mid_lat(average(
        bstBinaryRecords_.at(_it_msr->station1).currentLatitude,
        bstBinaryRecords_.at(_it_msr->station2).currentLatitude));
    double mid_long(average(
        bstBinaryRecords_.at(_it_msr->station1).currentLongitude,
        bstBinaryRecords_.at(_it_msr->station2).currentLongitude));
 
    matrix_2d rotations;
 
    Rotate_CartLocal<double>(gnss_cart, &gnss_local,
        bstBinaryRecords_.at(_it_msr->station1).currentLatitude,
        bstBinaryRecords_.at(_it_msr->station1).currentLongitude);
    Rotate_CartLocal<double>(gnss_adj_cart, &gnss_adj_local,
        bstBinaryRecords_.at(_it_msr->station1).currentLatitude,
        bstBinaryRecords_.at(_it_msr->station1).currentLongitude);
 
    // return iterator to the X component of the GNSS measurement
    _it_msr -= 2;
 
    switch (projectSettings_.o._adj_gnss_units)
    {
    case ENU_adj_gnss_ui:
        
        // term2: e
        // term3: n
        // term4: u
 
        // Propagate Variances from cartesian to local system - diagonals only
        PropagateVariances_CartLocal_Diagonal<double>(var_cart, var_local,
            mid_lat, mid_long,
            rotations, true);
        PropagateVariances_CartLocal_Diagonal<double>(var_adj_cart, var_adj_local,
            mid_lat, mid_long,
            rotations, false);
 
        // E
        _it_gnss_msr->preAdjMeas = gnss_local.get(0, 0);
        _it_gnss_msr->measAdj = gnss_adj_local.get(0, 0);
        _it_gnss_msr->measCorr = gnss_adj_local.get(0, 0) - gnss_local.get(0, 0);
 
        _it_gnss_msr->term2 = var_local.get(0, 0);
        _it_gnss_msr->measAdjPrec = var_adj_local.get(0, 0);
        _it_gnss_msr->residualPrec = _it_gnss_msr->term2 - _it_gnss_msr->measAdjPrec;
 
        // Update Pelzer reliability, N-Stat, T-Stat
        UpdateMsrRecordStats(_it_gnss_msr, _it_gnss_msr->term2);
 
        // Initialise database id iterator
        if (projectSettings_.o._database_ids)
            _it_dbid = v_msr_db_map_.begin() + std::distance(bmsBinaryRecords_.begin(), _it_msr);
 
        PrintAdjMeasurementsLinear('e', _it_gnss_msr, false);
    
        // N
        _it_msr++;
        _it_gnss_msr++;
        _it_gnss_msr->preAdjMeas = gnss_local.get(1, 0);
        _it_gnss_msr->measAdj = gnss_adj_local.get(1, 0);
        _it_gnss_msr->measCorr = gnss_adj_local.get(1, 0) - gnss_local.get(1, 0);
        
        _it_gnss_msr->term3 = var_local.get(1, 1);
        _it_gnss_msr->measAdjPrec = var_adj_local.get(1, 1);
        _it_gnss_msr->residualPrec = _it_gnss_msr->term3 - _it_gnss_msr->measAdjPrec;
 
        // Update Pelzer reliability, N-Stat, T-Stat
        UpdateMsrRecordStats(_it_gnss_msr, _it_gnss_msr->term3);
 
        // Initialise database id iterator
        if (projectSettings_.o._database_ids)
            _it_dbid = v_msr_db_map_.begin() + std::distance(bmsBinaryRecords_.begin(), _it_msr);
 
        PrintAdjMeasurementsLinear('n', _it_gnss_msr, false);
 
        // U
        _it_msr++;
        _it_gnss_msr++;
        _it_gnss_msr->preAdjMeas = gnss_local.get(2, 0);
        _it_gnss_msr->measAdj = gnss_adj_local.get(2, 0);
        _it_gnss_msr->measCorr = gnss_adj_local.get(2, 0) - gnss_local.get(2, 0);
        
        _it_gnss_msr->term4 = var_local.get(2, 2);
        _it_gnss_msr->measAdjPrec = var_adj_local.get(2, 2);
        _it_gnss_msr->residualPrec = _it_gnss_msr->term4 - _it_gnss_msr->measAdjPrec;
 
        // Update Pelzer reliability, N-Stat, T-Stat
        UpdateMsrRecordStats(_it_gnss_msr, _it_gnss_msr->term4);
 
        // Initialise database id iterator
        if (projectSettings_.o._database_ids)
            _it_dbid = v_msr_db_map_.begin() + std::distance(bmsBinaryRecords_.begin(), _it_msr);
 
        PrintAdjMeasurementsLinear('u', _it_gnss_msr, false);
        break;
    case AED_adj_gnss_ui:
 
        // term2: a
        // term3: e
        // term4: s
 
        azimuth = Direction(gnss_local.get(0, 0), gnss_local.get(1, 0));
        elevation = VerticalAngle(gnss_local.get(0, 0), gnss_local.get(1, 0), gnss_local.get(2, 0));
        distance = magnitude(gnss_local.get(0, 0), gnss_local.get(1, 0), gnss_local.get(2, 0));
        
        azimuthAdj = Direction(gnss_adj_local.get(0, 0), gnss_adj_local.get(1, 0));
        elevationAdj = VerticalAngle(gnss_adj_local.get(0, 0), gnss_adj_local.get(1, 0), gnss_adj_local.get(2, 0));
        distanceAdj = magnitude(gnss_adj_local.get(0, 0), gnss_adj_local.get(1, 0), gnss_adj_local.get(2, 0));
 
        // Propagate Variances from cartesian to local system - full matrix (for local-polar)
        PropagateVariances_LocalCart<double>(var_cart, var_local,
            mid_lat, mid_long, false,
            rotations, true);
        PropagateVariances_LocalCart<double>(var_adj_cart, var_adj_local,
            mid_lat, mid_long, false,
            rotations, false);
 
        // Propagate variance matrices from local reference frame to 
        // polar (azimuth, elevation angle and distance)
        PropagateVariances_LocalPolar_Diagonal<double>(var_local, var_polar, 
            azimuth, elevation, distance,
            rotations, true);
        PropagateVariances_LocalPolar_Diagonal<double>(var_adj_local, var_adj_polar, 
            azimuth, elevation, distance,
            rotations, false);
 
        // Print Geodetic azimuth
        _it_gnss_msr->preAdjMeas = azimuth;
        _it_gnss_msr->measAdj = azimuthAdj;
        _it_gnss_msr->measCorr = azimuthAdj - azimuth;
 
        _it_gnss_msr->term2 = var_polar.get(0, 0);
        _it_gnss_msr->measAdjPrec = var_adj_polar.get(0, 0);
        _it_gnss_msr->residualPrec = _it_gnss_msr->term2 - _it_gnss_msr->measAdjPrec;
 
        // Update Pelzer reliability, N-Stat, T-Stat
        UpdateMsrRecordStats(_it_gnss_msr, _it_gnss_msr->term2);
 
        // Initialise database id iterator
        if (projectSettings_.o._database_ids)
            _it_dbid = v_msr_db_map_.begin() + std::distance(bmsBinaryRecords_.begin(), _it_msr);
 
        PrintAdjMeasurementsAngular('a', _it_gnss_msr, false);
    
        // Print vertical angle
        _it_msr++;
        _it_gnss_msr++;
        _it_gnss_msr->preAdjMeas = elevation;
        _it_gnss_msr->measAdj = elevationAdj;
        _it_gnss_msr->measCorr = elevationAdj - elevation;
 
        _it_gnss_msr->term3 = var_polar.get(1, 1);
        _it_gnss_msr->measAdjPrec = var_adj_polar.get(1, 1);
        _it_gnss_msr->residualPrec = _it_gnss_msr->term3 - _it_gnss_msr->measAdjPrec;
 
        // Update Pelzer reliability, N-Stat, T-Stat
        UpdateMsrRecordStats(_it_gnss_msr, _it_gnss_msr->term3);
 
        // Initialise database id iterator
        if (projectSettings_.o._database_ids)
            _it_dbid = v_msr_db_map_.begin() + std::distance(bmsBinaryRecords_.begin(), _it_msr);
 
        PrintAdjMeasurementsAngular('v', _it_gnss_msr, false);
 
        // Print slope distance
        _it_msr++;
        _it_gnss_msr++;
        _it_gnss_msr->preAdjMeas = distance;
        _it_gnss_msr->measAdj = distanceAdj;
        _it_gnss_msr->measCorr = distanceAdj - distance;
 
        //var_polar.trace("var_polar", "%.16g ");
 
        _it_gnss_msr->term4 = var_polar.get(2, 2);
        _it_gnss_msr->measAdjPrec = var_adj_polar.get(2, 2);
        _it_gnss_msr->residualPrec = _it_gnss_msr->term4 - _it_gnss_msr->measAdjPrec;
 
        // Update Pelzer reliability, N-Stat, T-Stat
        UpdateMsrRecordStats(_it_gnss_msr, _it_gnss_msr->term4);
 
        // Initialise database id iterator
        if (projectSettings_.o._database_ids)
            _it_dbid = v_msr_db_map_.begin() + std::distance(bmsBinaryRecords_.begin(), _it_msr);
 
        PrintAdjMeasurementsLinear('s', _it_gnss_msr, false);
        break;
    case ADU_adj_gnss_ui:
 
        // term2: a
        // term3: s
        // term4: u
 
        azimuth = Direction(gnss_local.get(0, 0), gnss_local.get(1, 0));
        elevation = VerticalAngle(gnss_local.get(0, 0), gnss_local.get(1, 0), gnss_local.get(2, 0));
        distance = magnitude(gnss_local.get(0, 0), gnss_local.get(1, 0), gnss_local.get(2, 0));
        
        azimuthAdj = Direction(gnss_adj_local.get(0, 0), gnss_adj_local.get(1, 0));
        distanceAdj = magnitude(gnss_adj_local.get(0, 0), gnss_adj_local.get(1, 0), gnss_adj_local.get(2, 0));
 
        // Propagate Variances from cartesian to local system - full matrix (for local-polar)
        PropagateVariances_LocalCart<double>(var_cart, var_local,
            mid_lat, mid_long, false,
            rotations, true);
        PropagateVariances_LocalCart<double>(var_adj_cart, var_adj_local,
            mid_lat, mid_long, false,
            rotations, false);
 
        // Propagate variance matrices from local reference frame to 
        // polar (azimuth, distance and up)
        PropagateVariances_LocalPolar_Diagonal<double>(var_local, var_polar, 
            azimuth, elevation, distance,
            rotations, true);       
        PropagateVariances_LocalPolar_Diagonal<double>(var_adj_local, var_adj_polar, 
            azimuth, elevation, distance,
            rotations, false);
 
        // Print A
        _it_gnss_msr->preAdjMeas = azimuth;
        _it_gnss_msr->measAdj = azimuthAdj;
        _it_gnss_msr->measCorr = azimuthAdj - azimuth;
 
        _it_gnss_msr->term2 = var_polar.get(0, 0);
        _it_gnss_msr->measAdjPrec = var_adj_polar.get(0, 0);
        _it_gnss_msr->residualPrec = _it_gnss_msr->term2 - _it_gnss_msr->measAdjPrec;
 
        // Update Pelzer reliability, N-Stat, T-Stat
        UpdateMsrRecordStats(_it_gnss_msr, _it_gnss_msr->term2);
 
        // Initialise database id iterator
        if (projectSettings_.o._database_ids)
            _it_dbid = v_msr_db_map_.begin() + std::distance(bmsBinaryRecords_.begin(), _it_msr);
 
        PrintAdjMeasurementsAngular('a', _it_gnss_msr, false);
    
        // Print slope distance
        _it_msr++;
        _it_gnss_msr++;
        _it_gnss_msr->preAdjMeas = distance;
        _it_gnss_msr->measAdj = distanceAdj;
        _it_gnss_msr->measCorr = distanceAdj - distance;
 
        //var_polar.trace("var_polar", "%.16g ");
 
        _it_gnss_msr->term3 = var_polar.get(2, 2);
        _it_gnss_msr->measAdjPrec = var_adj_polar.get(2, 2);
        _it_gnss_msr->residualPrec = _it_gnss_msr->term3 - _it_gnss_msr->measAdjPrec;
 
        // Update Pelzer reliability, N-Stat, T-Stat
        UpdateMsrRecordStats(_it_gnss_msr, _it_gnss_msr->term3);
 
        // Initialise database id iterator
        if (projectSettings_.o._database_ids)
            _it_dbid = v_msr_db_map_.begin() + std::distance(bmsBinaryRecords_.begin(), _it_msr);
 
        PrintAdjMeasurementsLinear('s', _it_gnss_msr, false);
 
        // Print up
        _it_msr++;
        _it_gnss_msr++;
        _it_gnss_msr->preAdjMeas = gnss_local.get(2, 0);
        _it_gnss_msr->measAdj = gnss_adj_local.get(2, 0);
        _it_gnss_msr->measCorr = gnss_adj_local.get(2, 0) - gnss_local.get(2, 0);
 
        _it_gnss_msr->term4 = var_local.get(2, 2);
        _it_gnss_msr->measAdjPrec = var_adj_local.get(2, 2);
        _it_gnss_msr->residualPrec = _it_gnss_msr->term4 - _it_gnss_msr->measAdjPrec;
 
        // Update Pelzer reliability, N-Stat, T-Stat
        UpdateMsrRecordStats(_it_gnss_msr, _it_gnss_msr->term4);
 
        // Initialise database id iterator
        if (projectSettings_.o._database_ids)
            _it_dbid = v_msr_db_map_.begin() + std::distance(bmsBinaryRecords_.begin(), _it_msr);
 
        PrintAdjMeasurementsLinear('u', _it_gnss_msr, false);
        break;
    }
}

References _it_dbid, ADU_adj_gnss_ui, AED_adj_gnss_ui, average(), bmsBinaryRecords_, bstBinaryRecords_, DeserialiseBlockFromMappedFile(), Direction(), ENU_adj_gnss_ui, dynadjust::math::matrix_2d::fillupper(), dynadjust::math::matrix_2d::get(), magnitude(), mtx_lower, PrintAdjMeasurementsAngular(), PrintAdjMeasurementsLinear(), projectSettings_, PropagateVariances_CartLocal_Diagonal(), PropagateVariances_LocalCart(), PropagateVariances_LocalPolar_Diagonal(), Rotate_CartLocal(), sf_prec_adj_msrs, UnloadBlock(), UpdateMsrRecordStats(), v_msr_db_map_, v_precAdjMsrsFull_, and VerticalAngle().

Referenced by fillSinexExample(), and PrintAdjMeasurements_GXY().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurementStatistics()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurementStatistics	(	const char	cardinal,
		const it_vmsr_t &	_it_msr,
		bool	initialise_dbindex = true )

private

Definition at line 13226 of file dnaadjust.cpp.

{
    UINT16 PRECISION_STAT(2);
 
    if (isAdjustmentQuestionable_ || (fabs(_it_msr->NStat) > criticalValue_ * 4.0))
        adj_file << StringFromTW(removeNegativeZero(_it_msr->NStat, 2), STAT, PRECISION_STAT);        // N Stat
    else
        adj_file << std::setw(STAT) << std::setprecision(2) << std::fixed << std::right << 
            removeNegativeZero(_it_msr->NStat, 2);                                                    // N Stat   
 
    if (projectSettings_.o._adj_msr_tstat)
    {
        if (isAdjustmentQuestionable_ || (fabs(_it_msr->NStat) > criticalValue_ * 4.0))
            adj_file << StringFromTW(removeNegativeZero(_it_msr->TStat, 2), STAT, PRECISION_STAT);    // T Stat
        else
            adj_file << std::setw(STAT) << std::setprecision(2) << std::fixed << std::right << 
                removeNegativeZero(_it_msr->TStat, 2);                                                // T Stat
    }
 
    adj_file << std::setw(REL) << std::setprecision(2) << std::fixed << std::right << _it_msr->PelzerRel;                // Pelzer's reliability
 
    // Print measurement correction
    PrintMeasurementCorrection(cardinal, _it_msr);
 
    // Print asterisk for values which exceed the critical value
    if (fabs(_it_msr->NStat) > criticalValue_)
        adj_file << std::setw(OUTLIER) << std::right << "*";
    else
        adj_file << std::setw(OUTLIER) << std::right << " ";
 
    // Print measurement database ids
    if (projectSettings_.o._database_ids)
        PrintMeasurementDatabaseID(_it_msr, initialise_dbindex);
 
    adj_file << std::endl;
}

References adj_file, criticalValue_, isAdjustmentQuestionable_, OUTLIER(), PrintMeasurementCorrection(), PrintMeasurementDatabaseID(), projectSettings_, REL(), removeNegativeZero(), STAT(), and StringFromTW().

Referenced by fillSinexExample(), PrintAdjMeasurementsAngular(), and PrintAdjMeasurementsLinear().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintIgnoredAdjMeasurements()

void dynadjust::networkadjust::dna_adjust::PrintIgnoredAdjMeasurements ( bool printHeader )

private

Definition at line 11977 of file dnaadjust.cpp.

{
    // Print heading
    adj_file << std::endl;
    std::string table_heading("Ignored Measurements (a-posteriori)");
    PrintAdjMeasurementsHeader(printHeader, table_heading,
        ignoredMsrs, 0, false);
 
    vUINT32 ignored_msrs;
    it_vUINT32 _it_ign;
    it_vmsr_t _it_msr, _it_tmp;
 
    for (_it_msr = bmsBinaryRecords_.begin();
        _it_msr != bmsBinaryRecords_.end();
        ++_it_msr)
    {
        switch (_it_msr->measType)
        {
        case 'D':   // Direction set
            // Don't include internal directions
            if (_it_msr->measStart > xMeas)
                continue;
            break;
        case 'G':   // GPS Baseline cluster
        case 'X':   // GPS Baseline cluster
        case 'Y':   // GPS Point cluster
            // Don't include covariance terms
            if (_it_msr->measStart != xMeas)
                continue;
 
            if (_it_msr->vectorCount1 > 1)
                if ((_it_msr->vectorCount1 - _it_msr->vectorCount2) > 1)
                    continue;
            break;
        }
 
        // Include ignored measurements
        if (_it_msr->ignore)
        {
            _it_tmp = _it_msr;
            // Check each ignored measurement for the presence of
            // stations that are invalid (and therefore unadjusted).
            if (!IgnoredMeasurementContainsInvalidStation(&_it_msr))
                continue;
 
            ignored_msrs.push_back(static_cast<UINT32>(_it_tmp - bmsBinaryRecords_.begin()));
        }
    }
 
    if (ignored_msrs.empty())
    {
        adj_file << std::endl << std::endl;
        return;
    }
 
    // Update Ignored measurement records
    UINT32 clusterID(MAX_UINT32_VALUE);
 
    // Initialise ignored measurements on the first adjustment only.
    // Test for zero values (of the first ignored measurement) to determine 
    // if Ignored measurements have been updated. These values are initialised
    // at 0. by msr_t() in dnameasurement.hpp.  If this test fails, ignored 
    // measurements will not be calculated correctly (since the Update...() 
    // methods will refer to adjusted values)
    _it_msr = bmsBinaryRecords_.begin() + ignored_msrs.at(0);
    bool storeOriginalMeasurement(false);
    if (_it_msr->measAdj == 0. && _it_msr->measCorr == 0. && _it_msr->preAdjCorr == 0. && _it_msr->preAdjMeas == 0.)
        storeOriginalMeasurement = true;
 
    std::sort(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end());
 
    // Reduce measurements and compute stats
    for (_it_ign = ignored_msrs.begin(); _it_ign != ignored_msrs.end(); ++_it_ign)
    {
        _it_msr = bmsBinaryRecords_.begin() + (*_it_ign);
 
        // Update ignore measurements
        UpdateIgnoredMeasurements(&_it_msr, storeOriginalMeasurement);
    }
 
    // Print measurements
    for (_it_ign = ignored_msrs.begin(); _it_ign != ignored_msrs.end(); ++_it_ign)
    {
        _it_msr = bmsBinaryRecords_.begin() + (*_it_ign);
 
        // When a target direction is found, continue to next element.  
        if (_it_msr->measType == 'D')
            if (_it_msr->vectorCount1 < 1)
                continue;
 
        if (_it_msr->measStart != xMeas)
            continue;
 
        // For cluster measurements, only print measurement type if
        // this measurement is from a new cluster
        switch (_it_msr->measType)
        {
        case 'D':   // Direction set
        case 'X':   // GPS Baseline cluster
        case 'Y':   // GPS Point cluster
            if (_it_msr->clusterID != clusterID)
            {
                adj_file << std::left << std::setw(PAD2) << _it_msr->measType;
                clusterID = _it_msr->clusterID;
            }
            else
                adj_file << "  ";
            break;
        default:
            adj_file << std::left << std::setw(PAD2) << _it_msr->measType;
        }
 
#ifdef _MSDEBUG
        switch (_it_msr->measType)
        {
        case 'L':   // Level difference
            break;
        }
#endif
 
        UINT32 design_row(0);
 
        // normal format
        switch (_it_msr->measType)
        {
        case 'A':   // Horizontal angle
            PrintCompMeasurements_A(0, _it_msr, design_row, ignoredMsrs);
            break;
        case 'B':   // Geodetic azimuth
        case 'K':   // Astronomic azimuth
        case 'V':   // Zenith distance
        case 'Z':   // Vertical angle
            PrintCompMeasurements_BKVZ(0, _it_msr, design_row, ignoredMsrs);
            break;
        case 'C':   // Chord dist
        case 'E':   // Ellipsoid arc
        case 'L':   // Level difference
        case 'M':   // MSL arc
        case 'S':   // Slope distance
            PrintCompMeasurements_CELMS(_it_msr, design_row, ignoredMsrs);
            break;
        case 'D':   // Direction set
            PrintCompMeasurements_D(_it_msr, design_row, true);
            break;
        case 'H':   // Orthometric height
        case 'R':   // Ellipsoidal height
            PrintCompMeasurements_HR(0, _it_msr, design_row, ignoredMsrs);
            break;
        case 'I':   // Astronomic latitude
        case 'J':   // Astronomic longitude
        case 'P':   // Geodetic latitude
        case 'Q':   // Geodetic longitude
            PrintCompMeasurements_IJPQ(0, _it_msr, design_row, ignoredMsrs);
            break;
        case 'G':   // GPS Baseline (treat as single-baseline cluster)
        case 'X':   // GPS Baseline cluster
        case 'Y':   // GPS Point cluster
            PrintCompMeasurements_GXY(0, _it_msr, design_row, ignoredMsrs);
            break;
        }
 
    }
 
    adj_file << std::endl << std::endl;
    
}

References adj_file, bmsBinaryRecords_, IgnoredMeasurementContainsInvalidStation(), ignoredMsrs, MAX_UINT32_VALUE(), PAD2(), PrintAdjMeasurementsHeader(), PrintCompMeasurements_A(), PrintCompMeasurements_BKVZ(), PrintCompMeasurements_CELMS(), PrintCompMeasurements_D(), PrintCompMeasurements_GXY(), PrintCompMeasurements_HR(), PrintCompMeasurements_IJPQ(), UpdateIgnoredMeasurements(), v_blockStationsMapUnique_, and xMeas.

Referenced by fillSinexExample(), and PrintAdjustedNetworkMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurements_A()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurements_A ( it_vmsr_t & _it_msr )

private

Definition at line 13263 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station3).stationName;
 
    // Print angular measurement, taking care of user requirements for 
    // type, format and precision   
    PrintAdjMeasurementsAngular(' ', _it_msr);
}

References adj_file, bstBinaryRecords_, PrintAdjMeasurementsAngular(), and STATION().

Referenced by fillSinexExample(), and PrintAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurements_CELMS()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurements_CELMS ( it_vmsr_t & _it_msr )

private

Definition at line 13289 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
 
    PrintAdjMeasurementsLinear(' ', _it_msr);
}

References adj_file, bstBinaryRecords_, PrintAdjMeasurementsLinear(), and STATION().

Referenced by fillSinexExample(), and PrintAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurements_D()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurements_D ( it_vmsr_t & _it_msr )

private

Definition at line 13303 of file dnaadjust.cpp.

{       
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
 
    std::string ignoreFlag(" ");
    if (_it_msr->ignore)
        ignoreFlag = "*";
 
    UINT32 a, angle_count(_it_msr->vectorCount2 - 1);
    UINT32 skip(0), ignored(_it_msr->vectorCount1 - _it_msr->vectorCount2);
 
    adj_file << std::setw(PAD3) << std::left << ignoreFlag << std::setw(PAD2) << std::left << angle_count;
 
    if (projectSettings_.o._database_ids)
    {
        // Measured + Computed + Correction + Measured + Adjusted + Residual + N Stat + T Stat + Pelzer + Pre Adj Corr + Outlier
        UINT32 b(MSR + MSR + CORR + PREC + PREC + PREC + STAT + REL + PACORR + OUTLIER);
        if (projectSettings_.o._adj_msr_tstat)
            b += STAT;
        adj_file << std::setw(b) << " ";
 
        PrintMeasurementDatabaseID(_it_msr);
    }
    adj_file << std::endl;
 
    _it_msr++;
 
    for (a=0; a<angle_count; ++a)
    {
        // cater for ignored directions
        if (_it_msr->ignore)
        {
            while (skip < ignored)
            {
                skip++;
                _it_msr++;
                if (!_it_msr->ignore)
                    break;
            }
        }
 
        adj_file << std::left << std::setw(PAD2) << " ";                        // measurement type
        adj_file << std::left << std::setw(STATION) << " ";                  // station1 (Instrument)
        adj_file << std::left << std::setw(STATION) << " ";                  // station2 (RO)
        adj_file << std::left << std::setw(STATION) << 
            bstBinaryRecords_.at(_it_msr->station2).stationName;   // target
 
        // Print angular measurement, taking care of user requirements for 
        // type, format and precision   
        PrintAdjMeasurementsAngular(' ', _it_msr);
 
        _it_msr++;
    }
}

References adj_file, bstBinaryRecords_, CORR(), MSR(), OUTLIER(), PACORR(), PAD2(), PAD3(), PREC(), PrintAdjMeasurementsAngular(), PrintMeasurementDatabaseID(), projectSettings_, REL(), STAT(), and STATION().

Referenced by fillSinexExample(), and PrintAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurements_HR()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurements_HR ( it_vmsr_t & _it_msr )

private

Definition at line 13990 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
    adj_file << std::left << std::setw(STATION) << " ";
 
    PrintAdjMeasurementsLinear(' ', _it_msr);
}

References adj_file, bstBinaryRecords_, PrintAdjMeasurementsLinear(), and STATION().

Referenced by fillSinexExample(), and PrintAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurements_IJPQ()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurements_IJPQ ( it_vmsr_t & _it_msr )

private

Definition at line 14001 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
    adj_file << std::left << std::setw(STATION) << " ";
 
    // Print angular measurement, taking care of user requirements for 
    // type, format and precision   
    PrintAdjMeasurementsAngular(' ', _it_msr);
}

References adj_file, bstBinaryRecords_, PrintAdjMeasurementsAngular(), and STATION().

Referenced by fillSinexExample(), and PrintAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurements_BKVZ()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurements_BKVZ ( it_vmsr_t & _it_msr )

private

Definition at line 13276 of file dnaadjust.cpp.

{
    // normal format
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
    adj_file << std::left << std::setw(STATION) << " ";
 
    // Print angular measurement, taking care of user requirements for 
    // type, format and precision   
    PrintAdjMeasurementsAngular(' ', _it_msr);
}

References adj_file, bstBinaryRecords_, PrintAdjMeasurementsAngular(), and STATION().

Referenced by fillSinexExample(), and PrintAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurements_GXY()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurements_GXY	(	it_vmsr_t &	_it_msr,
		const uint32_uint32_pair &	b_pam )

private

Definition at line 13588 of file dnaadjust.cpp.

{
    // Is this a Y cluster specified in latitude, longitude, height?
    if (_it_msr->measType == 'Y')
    {
        if (_it_msr->station3 == LLH_type_i)
        {
            // Print phi, lambda, H
            PrintAdjMeasurements_YLLH(_it_msr);
            return;
        }
    }
 
    UINT32 cluster_msr, cluster_count(_it_msr->vectorCount1), covariance_count;
    bool nextElement(false);
 
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
    {
        if (nextElement)
            adj_file << std::left << std::setw(PAD2) << _it_msr->measType;
        else
            nextElement = true;
 
        covariance_count = _it_msr->vectorCount2;
 
        // first station
        adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station1).stationName;
    
        // Print second station?
        switch (_it_msr->measType)
        {
        case 'G':
        case 'X':
            adj_file << std::left << std::setw(STATION) << bstBinaryRecords_.at(_it_msr->station2).stationName;
            break;
        default:
            adj_file << std::left << std::setw(STATION) << " ";
        }
 
        // third station
        adj_file << std::left << std::setw(STATION) << " ";
        
        // Print adjusted GNSS baseline measurements in alternate units?
        if (projectSettings_.o._adj_gnss_units != XYZ_adj_gnss_ui &&
            _it_msr->measType != 'Y')
            PrintAdjGNSSAlternateUnits(_it_msr, b_pam);
        else
        {
            // Print X
            PrintAdjMeasurementsLinear('X', _it_msr);
    
            // Print Y
            _it_msr++;  
            PrintAdjMeasurementsLinear('Y', _it_msr);
 
            // Print Z
            _it_msr++;  
            PrintAdjMeasurementsLinear('Z', _it_msr);
        }
 
        // skip covariances until next baseline
        _it_msr += covariance_count * 3;
        
        if (covariance_count > 0)
            _it_msr++;
    }
}

References adj_file, bstBinaryRecords_, LLH_type_i, PAD2(), PrintAdjGNSSAlternateUnits(), PrintAdjMeasurements_YLLH(), PrintAdjMeasurementsLinear(), projectSettings_, STATION(), and XYZ_adj_gnss_ui.

Referenced by fillSinexExample(), and PrintAdjMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjMeasurements_YLLH()

void dynadjust::networkadjust::dna_adjust::PrintAdjMeasurements_YLLH ( it_vmsr_t & _it_msr )

private

Definition at line 13435 of file dnaadjust.cpp.

{
    // Get an iterator to this measurement which will be needed later when
    // obtaining variance matrices via GetGPSVarianceMatrix()
    it_vmsr_t _it_msr_begin(_it_msr);
    
    // create a temporary copy of this Y measurement and transform/propagate
    // cartesian elements to geographic
    vmsr_t y_msr;
    CopyClusterMsr<vmsr_t>(bmsBinaryRecords_, _it_msr, y_msr);
    
    it_vmsr_t _it_y_msr(y_msr.begin());
    snprintf(_it_y_msr->coordType, STN_TYPE_WIDTH, "%s", LLH_type);
    
    UINT32 covr, cluster_msr, cluster_count(_it_y_msr->vectorCount1), covariance_count;
    matrix_2d mpositions(cluster_count * 3, 1);
    double latitude, longitude, height;
 
    it_vstn_t stn1_it;
 
    // 1. Convert coordinates from cartesian to geographic
    ReduceYLLHMeasurementsforPrinting(y_msr, mpositions, adjustedMsrs);
    
    _it_y_msr = y_msr.begin();
 
    matrix_2d var_cart_adj(3, 3), var_geo_adj(3, 3);
 
    // 2. Convert adjusted precisions
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
    {
        covr = cluster_msr * 3;
        covariance_count = _it_y_msr->vectorCount2;
 
        var_cart_adj.put(0, 0, _it_y_msr->measAdjPrec);
        _it_y_msr++;
        var_cart_adj.put(1, 1, _it_y_msr->measAdjPrec);
        _it_y_msr++;    
        var_cart_adj.put(2, 2, _it_y_msr->measAdjPrec);
 
        latitude = mpositions.get(covr, 0);
        longitude = mpositions.get(covr+1, 0);
        height = mpositions.get(covr+2, 0);
 
        PropagateVariances_GeoCart<double>(var_cart_adj, &var_geo_adj,
            latitude, longitude, height,
            datum_.GetEllipsoidRef(), 
            false);         // Cartesian -> Geographic
 
        _it_y_msr-=2;
        _it_y_msr->measAdjPrec = var_geo_adj.get(0, 0);
 
        _it_y_msr++;
        _it_y_msr->measAdjPrec = var_geo_adj.get(1, 1);
        
        _it_y_msr++;    
        _it_y_msr->measAdjPrec = var_geo_adj.get(2, 2);
        
        // skip covariances until next point
        _it_y_msr += covariance_count * 3;
        
        if (covariance_count > 0)
            _it_y_msr++;
    }
 
    _it_y_msr = y_msr.begin();
 
    // 3. Convert apriori measurement precisions
 
    // Get measurement cartesian variance matrix
    matrix_2d var_cart;
    GetGPSVarianceMatrix(_it_msr_begin, &var_cart);
    var_cart.filllower();
 
    // Propagate the cartesian variance matrix to geographic
    PropagateVariances_GeoCart_Cluster<double>(var_cart, &var_cart,
        mpositions, 
        datum_.GetEllipsoidRef(), 
        false);         // Cartesian -> Geographic
 
    SetGPSVarianceMatrix(_it_y_msr, var_cart);
    
    // Now print the temporary measurement
    bool nextElement(false);
 
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
    {
        stn1_it = bstBinaryRecords_.begin() + _it_y_msr->station1;
 
        if (nextElement)
            adj_file << std::left << std::setw(PAD2) << _it_y_msr->measType;
        else
            nextElement = true;
 
        covariance_count = _it_y_msr->vectorCount2;
 
        // update statistics
        // Latitude
        _it_y_msr->residualPrec = _it_y_msr->term2 - _it_y_msr->measAdjPrec;
        if (_it_y_msr->residualPrec < 0.0)
            _it_y_msr->residualPrec = fabs(_it_y_msr->residualPrec);
        _it_y_msr->PelzerRel = sqrt(_it_y_msr->term2) / sqrt(_it_y_msr->residualPrec);
        if (_it_y_msr->PelzerRel < 0. || _it_y_msr->PelzerRel > STABLE_LIMIT)
            _it_y_msr->PelzerRel = UNRELIABLE;
        _it_y_msr->NStat = _it_y_msr->measCorr / sqrt(_it_y_msr->residualPrec);
        _it_y_msr++;
        
        // Longitude
        _it_y_msr->residualPrec = _it_y_msr->term3 - _it_y_msr->measAdjPrec;
        if (_it_y_msr->residualPrec < 0.0)
            _it_y_msr->residualPrec = fabs(_it_y_msr->residualPrec);
        _it_y_msr->PelzerRel = sqrt(_it_y_msr->term3) / sqrt(_it_y_msr->residualPrec);
        if (_it_y_msr->PelzerRel < 0. || _it_y_msr->PelzerRel > STABLE_LIMIT)
            _it_y_msr->PelzerRel = UNRELIABLE;
        _it_y_msr->NStat = _it_y_msr->measCorr / sqrt(_it_y_msr->residualPrec);
        _it_y_msr++;
 
        // Orthometric height
        _it_y_msr->residualPrec = _it_y_msr->term4 - _it_y_msr->measAdjPrec;
        if (_it_y_msr->residualPrec < 0.0)
            _it_y_msr->residualPrec = fabs(_it_y_msr->residualPrec);
        _it_y_msr->PelzerRel = sqrt(_it_y_msr->term4) / sqrt(_it_y_msr->residualPrec);
        if (_it_y_msr->PelzerRel < 0. || _it_y_msr->PelzerRel > STABLE_LIMIT)
            _it_y_msr->PelzerRel = UNRELIABLE;
        _it_y_msr->NStat = _it_y_msr->measCorr / sqrt(_it_y_msr->residualPrec);
        
        _it_y_msr-=2;
        
        // first, second, third stations
        adj_file << std::left << std::setw(STATION) << 
            stn1_it->stationName <<
            std::left << std::setw(STATION) << " " <<        // second station
            std::left << std::setw(STATION) << " ";      // third station
 
        // Print X
        PrintAdjMeasurementsAngular('P', _it_y_msr);
    
        // Print Y
        _it_y_msr++;    
        PrintAdjMeasurementsAngular('L', _it_y_msr);
 
        // Print Z
        _it_y_msr++;    
        PrintAdjMeasurementsLinear('H', _it_y_msr);
 
        // skip covariances until next point
        _it_y_msr += covariance_count * 3;
        
        if (covariance_count > 0)
            _it_y_msr++;
    }
    
}

References adj_file, adjustedMsrs, bmsBinaryRecords_, bstBinaryRecords_, CopyClusterMsr(), datum_, dynadjust::math::matrix_2d::filllower(), dynadjust::math::matrix_2d::get(), GetGPSVarianceMatrix(), LLH_type(), PAD2(), PrintAdjMeasurementsAngular(), PrintAdjMeasurementsLinear(), PropagateVariances_GeoCart(), PropagateVariances_GeoCart_Cluster(), ReduceYLLHMeasurementsforPrinting(), SetGPSVarianceMatrix(), STABLE_LIMIT(), STATION(), STN_TYPE_WIDTH(), and UNRELIABLE().

Referenced by fillSinexExample(), and PrintAdjMeasurements_GXY().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReduceYLLHMeasurementsforPrinting()

void dynadjust::networkadjust::dna_adjust::ReduceYLLHMeasurementsforPrinting	(	vmsr_t &	y_msr,
		matrix_2d &	mpositions,
		printMeasurementsMode	print_mode )

private

Definition at line 13361 of file dnaadjust.cpp.

{
    it_vmsr_t _it_y_msr(y_msr.begin());
    UINT32 covr, cluster_msr, cluster_count(_it_y_msr->vectorCount1), covariance_count;
    it_vstn_t stn1_it;
    double latitude, longitude, height, x, y, z;
 
    for (cluster_msr=0; cluster_msr<cluster_count; ++cluster_msr)
    {
        covr = cluster_msr * 3;
        covariance_count = _it_y_msr->vectorCount2;
 
        stn1_it = bstBinaryRecords_.begin() + _it_y_msr->station1;
 
        // transform computed values to geographic
        switch (print_mode)
        {
        case computedMsrs:
            x = _it_y_msr->term1;
            _it_y_msr++;
            y = _it_y_msr->term1;
            _it_y_msr++;
            z = _it_y_msr->term1;
            break;
        case adjustedMsrs:
        default:
            x = _it_y_msr->measAdj;
            _it_y_msr++;
            y = _it_y_msr->measAdj;
            _it_y_msr++;
            z = _it_y_msr->measAdj;
            break;
        }
        
        // Convert to geographic
        CartToGeo<double>(x, y, z, 
            &latitude, &longitude, &height, 
            datum_.GetEllipsoidRef());
 
        // Reduce ellipsoidal height to orthometric height
        if (fabs(stn1_it->geoidSep) > PRECISION_1E4)
            height -= stn1_it->geoidSep;        
 
        // Assign computed values
        _it_y_msr -= 2;
        _it_y_msr->measAdj = latitude;
        _it_y_msr->measCorr = latitude - _it_y_msr->preAdjMeas;
        mpositions.put(covr, 0, latitude);
        _it_y_msr++;
        _it_y_msr->measAdj = longitude;
        _it_y_msr->measCorr = longitude - _it_y_msr->preAdjMeas;
        mpositions.put(covr+1, 0, longitude);
        _it_y_msr++;
        _it_y_msr->measAdj = height;
        _it_y_msr->measCorr = height - _it_y_msr->preAdjMeas;
        mpositions.put(covr+2, 0, height);
 
        // skip covariances until next point
        _it_y_msr += covariance_count * 3;
 
        if (covariance_count > 0)
            _it_y_msr++;
    }
}

References adjustedMsrs, bstBinaryRecords_, CartToGeo(), computedMsrs, datum_, PRECISION_1E4(), and dynadjust::math::matrix_2d::put().

Referenced by fillSinexExample(), PrintAdjMeasurements_YLLH(), and PrintCompMeasurements_YLLH().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjStation()

void dynadjust::networkadjust::dna_adjust::PrintAdjStation	(	std::ostream &	os,
		const UINT32 &	block,
		const UINT32 &	stn,
		const UINT32 &	mat_idx,
		const matrix_2d *	stationEstimates,
		matrix_2d *	stationVariances,
		bool	recomputeGeographicCoords,
		bool	updateGeographicCoords,
		bool	reapplyTypeBUncertainties )

private

Definition at line 9590 of file dnaadjust.cpp.

{
    double estLatitude, estLongitude, estHeight, E(0.), N(0.), Zo(-1.);
 
    it_vstn_t stn_it(bstBinaryRecords_.begin());
    stn_it += stn;
 
    // station and constraint
    os << std::setw(STATION) << std::left << stn_it->stationName;
    os << std::setw(CONSTRAINT) << std::left << stn_it->stationConst;
 
    // Are station corrections required?  
    // If so, update the original stations matrix
    if (projectSettings_.o._init_stn_corrections || projectSettings_.o._stn_corr)
    {
        estHeight = stn_it->initialHeight;
        if (stn_it->suppliedHeightRefFrame == ORTHOMETRIC_type_i)
            estHeight = stn_it->initialHeight + stn_it->geoidSep;
 
        // update initial estimates
        GeoToCart<double>(
            stn_it->initialLatitude,
            stn_it->initialLongitude,
            estHeight,
            v_originalStations_.at(block).getelementref(mat_idx, 0),
            v_originalStations_.at(block).getelementref(mat_idx+1, 0),
            v_originalStations_.at(block).getelementref(mat_idx+2, 0),
            datum_.GetEllipsoidRef());
    }
 
    // Are geographic coordinates required?
    if (recomputeGeographicCoords ||
        projectSettings_.o._stn_coord_types.find("P") != std::string::npos ||
        projectSettings_.o._stn_coord_types.find("L") != std::string::npos ||
        projectSettings_.o._stn_coord_types.find("H") != std::string::npos ||
        projectSettings_.o._stn_coord_types.find("h") != std::string::npos ||
        projectSettings_.o._stn_coord_types.find("N") != std::string::npos ||
        projectSettings_.o._stn_coord_types.find("z") != std::string::npos)
    {
        CartToGeo<double>(
            stationEstimates->get(mat_idx, 0),       // X
            stationEstimates->get(mat_idx+1, 0), // Y
            stationEstimates->get(mat_idx+2, 0), // Z
            &estLatitude,                           // Lat
            &estLongitude,                          // Long
            &estHeight,                             // E.Height
            datum_.GetEllipsoidRef());                
 
        if (updateGeographicCoords)
        {
            stn_it->currentLatitude = estLatitude;
            stn_it->currentLongitude = estLongitude;
            stn_it->currentHeight = estHeight;
        }
    }
 
    // Are projection coordinates required?
    if (projectSettings_.o._stn_coord_types.find("E") != std::string::npos ||
        projectSettings_.o._stn_coord_types.find("N") != std::string::npos ||
        projectSettings_.o._stn_coord_types.find("z") != std::string::npos)
    {
        GeoToGrid<double>(estLatitude, estLongitude, &E, &N, &Zo,
            datum_.GetEllipsoidRef(), 
            &projection_, true);     // compute zone
    }
 
    for (_it_str_const it_s=projectSettings_.o._stn_coord_types.begin(); it_s!=projectSettings_.o._stn_coord_types.end(); ++it_s)
    {
        char c = it_s[0];
 
        switch (c)
        {
        case 'P':
            // latitude
            // Which angular format?
            if (projectSettings_.o._angular_type_stn == DMS)
                os << std::setprecision(4 + PRECISION_SEC_STN) << std::fixed << std::right << std::setw(LAT_EAST) <<
                    RadtoDms(estLatitude);
            else
                os << std::setprecision(4 + PRECISION_SEC_STN) << std::fixed << std::right << std::setw(LAT_EAST) <<
                    Degrees(estLatitude);
            break;
        case 'L':
            // longitude
            // Which angular format?
            if (projectSettings_.o._angular_type_stn == DMS)
                os << std::setprecision(4+PRECISION_SEC_STN) << std::fixed << std::right << std::setw(LON_NORTH) << 
                    RadtoDmsL(estLongitude);
            else
                os << std::setprecision(4 + PRECISION_SEC_STN) << std::fixed << std::right << std::setw(LON_NORTH) <<
                    DegreesL(estLongitude);
            break;
        case 'E':
            // Easting
            os << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(LAT_EAST) << E;
            break;
        case 'N':
            // Northing
            os << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(LON_NORTH) << N;
            break;
        case 'z':
            // Zone
            os << std::setprecision(0) << std::fixed << std::right << std::setw(ZONE) << Zo;
            break;
        case 'H':
            // Orthometric height
            if (isAdjustmentQuestionable_)
                os << std::right << StringFromTW((estHeight - stn_it->geoidSep), HEIGHT, PRECISION_MTR_STN);
            else
                os << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(HEIGHT) << 
                    estHeight - stn_it->geoidSep;
            break;
        case 'h':
            // Ellipsoidal height
            if (isAdjustmentQuestionable_)
                os << std::right << StringFromTW(estHeight, HEIGHT, PRECISION_MTR_STN);
            else
                os << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(HEIGHT) << 
                    estHeight;
            break;
        case 'X':
            // Cartesian X
            os << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(XYZ) << 
                stationEstimates->get(mat_idx, 0);
            break;
        case 'Y':
            // Cartesian Y
            os << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(XYZ) << 
                stationEstimates->get(mat_idx+1, 0);
            break;
        case 'Z':
            // Cartesian Z
            os << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(XYZ) << 
                stationEstimates->get(mat_idx+2, 0);
            break;
        }
    }
 
    os << std::setw(PAD2) << " ";
 
    // Standard deviation in local reference frame
    matrix_2d var_local(3, 3), var_cart(3, 3);
 
    // To minimise re-computation when printing to .xyz, .adj and .apu, the type b uncertainties are 
    // added to the estimated variances held in memory. This is not a problem since, if adjust is 
    // re-run and the user does not supply type b uncertainties, the variances held in memory will be 
    // re-estimated which will overwrite the type b values that were previously applied.
 
    // Add type B uncertainties (if required)
    if (reapplyTypeBUncertainties &&
        (projectSettings_.o._apply_type_b_global || projectSettings_.o._apply_type_b_file))
    {
        if (v_typeBUncertaintyMethod_.at(stn).apply)
        {
            // apply local first
            if (v_typeBUncertaintyMethod_.at(stn).method == type_b_local)
            {
                // Add the cartesian type b variances 
                // Note: Cartesian variances for this station were computed in dna_io_tbu::reduce_uncertainties_local(...)
                //var_cart.add(v_typeBUncertaintiesLocal_.at(v_stationTypeBMap_.at(stn).second).type_b);
                stationVariances->blockadd(mat_idx, mat_idx,
                    v_typeBUncertaintiesLocal_.at(v_stationTypeBMap_.at(stn).second).type_b,
                    0, 0, 3, 3);
            }
            else if (v_typeBUncertaintyMethod_.at(stn).method == type_b_global)
            {
                // Compute cartesian variances for this station from the global uncertainty
                // Note: this needs to be done for each site from the global type b uncertainties entered 
                // via the command line
                matrix_2d var_cart_typeb(3, 3);
                PropagateVariances_LocalCart<double>(typeBUncertaintyGlobal_.type_b, var_cart_typeb,
                    estLatitude, estLongitude, true);
 
                // Add the cartesian type b variances 
                //var_cart.add(var_cart_typeb);
                stationVariances->blockadd(mat_idx, mat_idx,
                    var_cart_typeb, 0, 0, 3, 3);
            }   
        }
    }
 
    var_cart.copyelements(0, 0, stationVariances, mat_idx, mat_idx, 3, 3);
 
    PropagateVariances_LocalCart(var_cart, var_local, 
        estLatitude, estLongitude, false);
    
    if (isAdjustmentQuestionable_)
        os <<
            StringFromTW(sqrt(var_local.get(0, 0)), STDDEV, PRECISION_MTR_STN) <<
            StringFromTW(sqrt(var_local.get(1, 1)), STDDEV, PRECISION_MTR_STN) <<
            StringFromTW(sqrt(var_local.get(2, 2)), STDDEV, PRECISION_MTR_STN);
    else
        os <<
            std::setw(STDDEV) << std::right << StringFromT(sqrt(var_local.get(0, 0)), PRECISION_MTR_STN) <<
            std::setw(STDDEV) << std::right << StringFromT(sqrt(var_local.get(1, 1)), PRECISION_MTR_STN) <<
            std::setw(STDDEV) << std::right << StringFromT(sqrt(var_local.get(2, 2)), PRECISION_MTR_STN);
 
    if (projectSettings_.o._stn_corr)
    {
        double cor_e, cor_n, cor_up;
        ComputeLocalElements3D<double>(
            v_originalStations_.at(block).get(mat_idx, 0),       // original X
            v_originalStations_.at(block).get(mat_idx+1, 0), // original Y
            v_originalStations_.at(block).get(mat_idx+2, 0), // original Z
            stationEstimates->get(mat_idx, 0),                   // estimated X
            stationEstimates->get(mat_idx+1, 0),             // estimated Y
            stationEstimates->get(mat_idx+2, 0),             // estimated Z
            stn_it->currentLatitude,
            stn_it->currentLongitude,
            &cor_e, &cor_n, &cor_up);                   // corrections in the local reference frame
 
        os << std::setw(PAD2) << " " << 
            std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(HEIGHT) << cor_e << 
            std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(HEIGHT) << cor_n << 
            std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(HEIGHT) << cor_up;
    }
 
    // description
    os << std::setw(PAD2) << " " << std::left << stn_it->description;
    os << std::endl;
    
}

References dynadjust::math::matrix_2d::blockadd(), bstBinaryRecords_, CartToGeo(), ComputeLocalElements3D(), CONSTRAINT(), dynadjust::math::matrix_2d::copyelements(), datum_, Degrees(), DegreesL(), DMS, GeoToCart(), GeoToGrid(), dynadjust::math::matrix_2d::get(), HEIGHT(), isAdjustmentQuestionable_, LAT_EAST(), LON_NORTH(), ORTHOMETRIC_type_i, PAD2(), PRECISION_MTR_STN, PRECISION_SEC_STN, projection_, projectSettings_, PropagateVariances_LocalCart(), RadtoDms(), RadtoDmsL(), STATION(), STDDEV(), StringFromT(), StringFromTW(), dynadjust::iostreams::type_b_global, dynadjust::iostreams::type_b_local, typeBUncertaintyGlobal_, v_originalStations_, v_stationTypeBMap_, v_typeBUncertaintiesLocal_, v_typeBUncertaintyMethod_, XYZ(), and ZONE().

Referenced by fillSinexExample(), PrintAdjStations(), and PrintAdjStationsUniqueList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjStations()

void dynadjust::networkadjust::dna_adjust::PrintAdjStations	(	std::ostream &	os,
		const UINT32 &	block,
		const matrix_2d *	stationEstimates,
		matrix_2d *	stationVariances,
		bool	printBlockID,
		bool	recomputeGeographicCoords,
		bool	updateGeographicCoords,
		bool	printHeader,
		bool	reapplyTypeBUncertainties )

private

Definition at line 9817 of file dnaadjust.cpp.

{
    vUINT32 v_blockStations(v_parameterStationList_.at(block));
 
    if (v_blockStations.size() * 3 != stationEstimates->rows())
    {
        std::stringstream ss;
        ss << "PrintAdjStations(): Number of estimated stations in block " << block << 
            " does not match the block station count." << std::endl;
        SignalExceptionAdjustment(ss.str(), 0);
    }
 
    dna_io_adj adj;
 
    try {
 
        if (printHeader)
            adj.print_adj_stn_header(os);
 
        // if required, sort stations according to original station file order
        if (projectSettings_.o._sort_stn_file_order)
            SortStationsbyFileOrder(v_blockStations);
 
        switch (projectSettings_.a.adjust_mode)
        {
        case SimultaneousMode:
            adj.print_stn_info_col_header(os, 
                projectSettings_.o._stn_coord_types, projectSettings_.o._stn_corr);
            break;
        case PhasedMode:
        case Phased_Block_1Mode:      // only the first block is rigorous
            // Print stations in each block?
            if (projectSettings_.o._output_stn_blocks)
            {
                if (printBlockID)
                    os << "Block " << block + 1 << std::endl;
                else if (projectSettings_.o._adj_stn_iteration)
                    adj.print_adj_stn_block_header(os, block);
            
                adj.print_stn_info_col_header(os, 
                    projectSettings_.o._stn_coord_types, projectSettings_.o._stn_corr);
            }
            else 
            {
                if (block == 0)
                    adj.print_stn_info_col_header(os, 
                        projectSettings_.o._stn_coord_types, projectSettings_.o._stn_corr);
            }
            break;
        }
 
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
    
    UINT32 mat_idx, stn;
 
    // Print stations according to the user-defined sort order
    for (UINT32 i(0); i<v_blockStationsMap_.at(block).size(); ++i)
    {
        stn = v_blockStations.at(i);
        mat_idx = v_blockStationsMap_.at(block)[stn] * 3;
 
        PrintAdjStation(os, block, stn, mat_idx,
            stationEstimates, stationVariances, 
            recomputeGeographicCoords, updateGeographicCoords,
            reapplyTypeBUncertainties);
    }
 
    os << std::endl;
 
    // return sort order to alpha-numeric
    if (projectSettings_.o._sort_stn_file_order)
        SortStationsbyID(v_blockStations);
}

References Phased_Block_1Mode, PhasedMode, dynadjust::iostreams::dna_io_adj::print_adj_stn_block_header(), dynadjust::iostreams::dna_io_adj::print_adj_stn_header(), dynadjust::iostreams::dna_io_adj::print_stn_info_col_header(), PrintAdjStation(), projectSettings_, dynadjust::math::matrix_2d::rows(), SignalExceptionAdjustment(), SimultaneousMode, SortStationsbyFileOrder(), SortStationsbyID(), v_blockStationsMap_, and v_parameterStationList_.

Referenced by AdjustSimultaneous(), CarryForwardJunctions(), fillSinexExample(), PrintAdjustedNetworkStations(), UpdateEstimatesFinal(), and UpdateEstimatesReverse().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintAdjStationsUniqueList()

void dynadjust::networkadjust::dna_adjust::PrintAdjStationsUniqueList	(	std::ostream &	os,
		const v_mat_2d *	stationEstimates,
		v_mat_2d *	stationVariances,
		bool	recomputeGeographicCoords,
		bool	updateGeographicCoords,
		bool	reapplyTypeBUncertainties )

private

Definition at line 9897 of file dnaadjust.cpp.

{
    try {
        // Print header info and columns to adj file.  Throws runtime_error on failure.
        dna_io_adj adj;
        adj.print_adj_stn_header(os);
        adj.print_stn_info_col_header(os, 
            projectSettings_.o._stn_coord_types, projectSettings_.o._stn_corr);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
 
    UINT32 block(UINT_MAX), stn, mat_index;
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Determine sort order of block Stations Map
    if (projectSettings_.a.stage || projectSettings_.a.adjust_mode == Phased_Block_1Mode)
    {
        // sort by blocks to create efficiency when deserialising matrix info
        std::sort(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end(), 
            CompareBlockStationMapUnique_byBlock<u32u32_uint32_pair>());
    }
    else if (projectSettings_.o._sort_stn_file_order)
    {
        CompareBlockStationMapUnique_byFileOrder<station_t, u32u32_uint32_pair> stnorderCompareFunc(&bstBinaryRecords_);
        std::sort(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end(), stnorderCompareFunc);
    }
    else
        std::sort(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end());
    
    std::stringstream stationRecord;
    v_uint32_string_pair stationsOutput;
    stationsOutput.reserve(v_blockStationsMapUnique_.size());
 
    std::ostream* outstream(&os);
    if (projectSettings_.a.stage)
        outstream = &stationRecord;
 
    // Print stations according to the user-defined sort order
    for (_it_bsmu=v_blockStationsMapUnique_.begin();
        _it_bsmu!=v_blockStationsMapUnique_.end(); ++_it_bsmu)
    {
        // If this is not the first block, exit if block-1 mode
        if (projectSettings_.a.adjust_mode == Phased_Block_1Mode)
            if (_it_bsmu->second > 0)
                break;
 
        if (projectSettings_.a.stage)
        {
            if (block != _it_bsmu->second)
            {
                // unload previous block
                if (_it_bsmu->second > 0)
                {
                    UnloadBlock(_it_bsmu->second-1, 2, sf_rigorous_stns, sf_rigorous_vars);
 
                    // Were original station estimates updated?  If so, serialise, otherwise unload
                    if (projectSettings_.o._init_stn_corrections || projectSettings_.o._stn_corr)
                        SerialiseBlockToMappedFile(_it_bsmu->second-1, 1,
                            sf_original_stns);
                }
 
                // load up this block
                DeserialiseBlockFromMappedFile(_it_bsmu->second, 2,
                    sf_rigorous_stns, sf_rigorous_vars);
 
                if (projectSettings_.o._init_stn_corrections || projectSettings_.o._stn_corr)
                    DeserialiseBlockFromMappedFile(_it_bsmu->second, 1, 
                        sf_original_stns);
                
            }
        }
 
        block = _it_bsmu->second;
        stn = _it_bsmu->first.first;
        mat_index = _it_bsmu->first.second * 3;
 
        PrintAdjStation(*outstream, 
            block, stn, mat_index, 
            &stationEstimates->at(block), &stationVariances->at(block), 
            recomputeGeographicCoords, updateGeographicCoords,
            reapplyTypeBUncertainties);
 
        if (projectSettings_.a.stage)
        {       
            stationsOutput.push_back(uint32_string_pair(stn, stationRecord.str()));
            stationRecord.str("");
        }   
    }
 
    if (projectSettings_.a.stage)
    {
        UnloadBlock(block, 2, sf_rigorous_stns, sf_rigorous_vars);
        
        // Were original station estimates updated?  If so, serialise, otherwise unload
        if (projectSettings_.o._init_stn_corrections || projectSettings_.o._stn_corr)
            SerialiseBlockToMappedFile(block, 1,
                sf_original_stns);
 
        // if required, sort stations according to original station file order
        if (projectSettings_.o._sort_stn_file_order)
        {
            CompareOddPairFirst_FileOrder<station_t, UINT32, std::string> stnorderCompareFunc(&bstBinaryRecords_);
            std::sort(stationsOutput.begin(), stationsOutput.end(), stnorderCompareFunc);
        }
        else
            std::sort(stationsOutput.begin(), stationsOutput.end(), CompareOddPairFirst<UINT32, std::string>());
 
        for_each(stationsOutput.begin(), stationsOutput.end(),
            [&stationsOutput, &os] (std::pair<UINT32, std::string>& adjRecord) { 
                os << adjRecord.second;
            }
        );
    }
 
    os << std::endl;
}

References bstBinaryRecords_, DeserialiseBlockFromMappedFile(), Phased_Block_1Mode, dynadjust::iostreams::dna_io_adj::print_adj_stn_header(), dynadjust::iostreams::dna_io_adj::print_stn_info_col_header(), PrintAdjStation(), projectSettings_, SerialiseBlockToMappedFile(), sf_original_stns, sf_rigorous_stns, sf_rigorous_vars, SignalExceptionAdjustment(), UnloadBlock(), and v_blockStationsMapUnique_.

Referenced by fillSinexExample(), and PrintAdjustedNetworkStations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCorStations()

void dynadjust::networkadjust::dna_adjust::PrintCorStations	(	std::ostream &	cor_file,
		const UINT32 &	block )

private

Definition at line 10346 of file dnaadjust.cpp.

{
    vUINT32 v_blockStations(v_parameterStationList_.at(block));
    
    // if required, sort stations according to original station file order
    if (projectSettings_.o._sort_stn_file_order)
        SortStationsbyFileOrder(v_blockStations);
    
    switch (projectSettings_.a.adjust_mode)
    {
    case PhasedMode:
    case Phased_Block_1Mode:      // only the first block is rigorous
        cor_file << "Block " << block + 1 << std::endl;
        break;
    }
 
    cor_file << std::setw(STATION) << std::left << "Station" <<
        std::setw(PAD2) << " " << 
        std::right << std::setw(MSR) << "Azimuth" << 
        std::right << std::setw(MSR) << "V. Angle" << 
        std::right << std::setw(MSR) << "S. Distance" << 
        std::right << std::setw(MSR) << "H. Distance" << 
        std::right << std::setw(HEIGHT) << "east" << 
        std::right << std::setw(HEIGHT) << "north" << 
        std::right << std::setw(HEIGHT) << "up" << std::endl;
 
    UINT32 i, j = STATION+PAD2+MSR+MSR+MSR+MSR+HEIGHT+HEIGHT+HEIGHT;
 
    for (i=0; i<j; ++i)
        cor_file << "-";
    cor_file << std::endl;
 
    UINT32 mat_idx, stn;
 
    pv_mat_2d estimates(&v_rigorousStations_);
    if (projectSettings_.a.adjust_mode == SimultaneousMode)
        estimates = &v_estimatedStations_;
 
    // Print stations according to the user-defined sort order
    for (i=0; i<v_blockStationsMap_.at(block).size(); ++i)
    {
        stn = v_blockStations.at(i);
        mat_idx = v_blockStationsMap_.at(block)[stn] * 3;
 
        PrintCorStation(cor_file, block, stn, mat_idx, 
            &estimates->at(block));
    }
 
    cor_file << std::endl;
 
    // return sort order to alpha-numeric
    if (projectSettings_.o._sort_stn_file_order)
        SortStationsbyID(v_blockStations);
 
}

References HEIGHT(), MSR(), PAD2(), Phased_Block_1Mode, PhasedMode, PrintCorStation(), projectSettings_, SimultaneousMode, SortStationsbyFileOrder(), SortStationsbyID(), STATION(), v_blockStationsMap_, v_estimatedStations_, v_parameterStationList_, and v_rigorousStations_.

Referenced by fillSinexExample(), and PrintNetworkStationCorrections().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCorStationsUniqueList()

void dynadjust::networkadjust::dna_adjust::PrintCorStationsUniqueList ( std::ostream & cor_file )

private

Definition at line 10402 of file dnaadjust.cpp.

{
    vUINT32 v_blockStations;
    vstring stn_corr_records(bstBinaryRecords_.size());
 
    cor_file << std::setw(STATION) << std::left << "Station" <<
        std::setw(PAD2) << " " << 
        std::right << std::setw(MSR) << "Azimuth" << 
        std::right << std::setw(MSR) << "V. Angle" << 
        std::right << std::setw(MSR) << "S. Distance" << 
        std::right << std::setw(MSR) << "H. Distance" << 
        std::right << std::setw(HEIGHT) << "east" << 
        std::right << std::setw(HEIGHT) << "north" << 
        std::right << std::setw(HEIGHT) << "up" << std::endl;
 
    UINT32 i, j = STATION+PAD2+MSR+MSR+MSR+MSR+HEIGHT+HEIGHT+HEIGHT;
 
    for (i=0; i<j; ++i)
        cor_file << "-";
    cor_file << std::endl;
 
    UINT32 block(UINT_MAX), stn, mat_index;
    _it_u32u32_uint32_pair _it_bsmu;
    
    std::stringstream stationRecord;
    v_uint32_string_pair correctionsOutput;
    correctionsOutput.reserve(v_blockStationsMapUnique_.size());
 
    pv_mat_2d estimates(&v_rigorousStations_);
    if (projectSettings_.a.adjust_mode == SimultaneousMode)
        estimates = &v_estimatedStations_;
 
    std::ostream* outstream(&cor_file);
    if (projectSettings_.a.stage)
        outstream = &stationRecord;
 
    // No need to sort order of block Stations Map - this was done in
    // PrintAdjStationsUniqueList
 
    for (_it_bsmu=v_blockStationsMapUnique_.begin();
        _it_bsmu!=v_blockStationsMapUnique_.end(); ++_it_bsmu)
    {
        // If this is not the first block, exit if block-1 mode
        if (projectSettings_.a.adjust_mode == Phased_Block_1Mode)
            if (_it_bsmu->second > 0)
                break;
 
        if (projectSettings_.a.stage)
        {
            if (block != _it_bsmu->second)
            {
                // unload previous block
                if (_it_bsmu->second > 0)
                    UnloadBlock(_it_bsmu->second-1, 2, 
                        sf_rigorous_stns, sf_original_stns);
 
                // load up this block
                if (projectSettings_.a.stage)
                    DeserialiseBlockFromMappedFile(_it_bsmu->second, 2,
                        sf_rigorous_stns, sf_original_stns);
            }
        }
 
        block = _it_bsmu->second;
        stn = _it_bsmu->first.first;
        mat_index = _it_bsmu->first.second * 3;
 
        PrintCorStation(*outstream, block, stn, mat_index,
            &estimates->at(block));
            
        if (projectSettings_.a.stage)
        {
            correctionsOutput.push_back(uint32_string_pair(stn, stationRecord.str()));
            stationRecord.str("");
        }
    }
 
    if (projectSettings_.a.stage)
        UnloadBlock(block, 2, 
            sf_rigorous_stns, sf_original_stns);
 
    // if required, sort stations according to original station file order
    if (projectSettings_.o._sort_stn_file_order)
    {
        CompareOddPairFirst_FileOrder<station_t, UINT32, std::string> stnorderCompareFunc(&bstBinaryRecords_);
        std::sort(correctionsOutput.begin(), correctionsOutput.end(), stnorderCompareFunc);
    }
    else
        std::sort(correctionsOutput.begin(), correctionsOutput.end(), CompareOddPairFirst<UINT32, std::string>());
 
    for_each(correctionsOutput.begin(), correctionsOutput.end(),
        [&correctionsOutput, &cor_file] (std::pair<UINT32, std::string>& corrRecord) { 
            cor_file << corrRecord.second;
        }
    );
}

References bstBinaryRecords_, DeserialiseBlockFromMappedFile(), HEIGHT(), MSR(), PAD2(), Phased_Block_1Mode, PrintCorStation(), projectSettings_, sf_original_stns, sf_rigorous_stns, SimultaneousMode, STATION(), UnloadBlock(), v_blockStationsMapUnique_, v_estimatedStations_, and v_rigorousStations_.

Referenced by fillSinexExample(), and PrintNetworkStationCorrections().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintCorStation()

void dynadjust::networkadjust::dna_adjust::PrintCorStation	(	std::ostream &	os,
		const UINT32 &	block,
		const UINT32 &	stn,
		const UINT32 &	mat_idx,
		const matrix_2d *	stationEstimates )

private

Definition at line 9505 of file dnaadjust.cpp.

{
    double vertical_angle, azimuth, slope_distance, horiz_distance, 
        local_12e, local_12n, local_12up;
 
    // calculate vertical angle
    vertical_angle = VerticalAngle(
        v_originalStations_.at(block).get(mat_index, 0),     // X1
        v_originalStations_.at(block).get(mat_index+1, 0),       // Y1
        v_originalStations_.at(block).get(mat_index+2, 0),       // Z1
        stationEstimates->get(mat_index, 0),     // X2
        stationEstimates->get(mat_index+1, 0),       // Y2
        stationEstimates->get(mat_index+2, 0),       // Z2
        bstBinaryRecords_.at(stn).currentLatitude,
        bstBinaryRecords_.at(stn).currentLongitude,
        bstBinaryRecords_.at(stn).currentLatitude,
        bstBinaryRecords_.at(stn).currentLongitude,
        0., 0.,
        &local_12e, &local_12n, &local_12up);
 
    if (fabs(local_12e) < PRECISION_1E5)
        if (fabs(local_12n) < PRECISION_1E5)
            if (fabs(local_12up) < PRECISION_1E5)
                vertical_angle = 0.;
        
    // Is the vertical correction within the user-specified tolerance?
    if (fabs(local_12up) < projectSettings_.o._vt_corr_threshold)
        return;
 
    // compute horizontal correction
    horiz_distance = magnitude(local_12e, local_12n);
        
    // Is the horizontal correction within the user-specified tolerance?
    if (horiz_distance < projectSettings_.o._hz_corr_threshold)
        return;
        
    // calculate azimuth
    azimuth = Direction(
        v_originalStations_.at(block).get(mat_index, 0),     // X1
        v_originalStations_.at(block).get(mat_index+1, 0),       // Y1
        v_originalStations_.at(block).get(mat_index+2, 0),       // Z1
        stationEstimates->get(mat_index, 0),     // X2
        stationEstimates->get(mat_index+1, 0),       // Y2
        stationEstimates->get(mat_index+2, 0),       // Z2
        bstBinaryRecords_.at(stn).currentLatitude,
        bstBinaryRecords_.at(stn).currentLongitude,
        &local_12e, &local_12n);
 
    if (fabs(local_12e) < PRECISION_1E5)
        if (fabs(local_12n) < PRECISION_1E5)
            azimuth = 0.;
 
    // calculate distances
    slope_distance = magnitude(
        v_originalStations_.at(block).get(mat_index, 0),     // X1
        v_originalStations_.at(block).get(mat_index+1, 0),       // Y1
        v_originalStations_.at(block).get(mat_index+2, 0),       // Z1
        stationEstimates->get(mat_index, 0),     // X2
        stationEstimates->get(mat_index+1, 0),       // Y2
        stationEstimates->get(mat_index+2, 0));      // Z2
        
    // print...
    // station and constraint
    os << std::setw(STATION) << std::left << bstBinaryRecords_.at(stn).stationName << std::setw(PAD2) << " ";
    // data
    os << std::setw(MSR) << std::right << FormatDmsString(RadtoDms(azimuth), 4, true, false) << 
        std::setw(MSR) << std::right << FormatDmsString(RadtoDms(vertical_angle), 4, true, false) << 
        std::setw(MSR) << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << slope_distance << 
        std::setw(MSR) << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << horiz_distance;
 
    if (isAdjustmentQuestionable_)
        os << 
            StringFromTW(local_12e, HEIGHT, PRECISION_MTR_STN) << 
            StringFromTW(local_12n, HEIGHT, PRECISION_MTR_STN) << 
            StringFromTW(local_12up, HEIGHT, PRECISION_MTR_STN) << std::endl;
    else
        os << 
            std::setw(HEIGHT) << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << local_12e << 
            std::setw(HEIGHT) << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << local_12n << 
            std::setw(HEIGHT) << std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << local_12up << std::endl;
}

References bstBinaryRecords_, Direction(), FormatDmsString(), dynadjust::math::matrix_2d::get(), HEIGHT(), isAdjustmentQuestionable_, magnitude(), MSR(), PAD2(), PRECISION_1E5(), PRECISION_MTR_STN, projectSettings_, RadtoDms(), STATION(), StringFromTW(), v_originalStations_, and VerticalAngle().

Referenced by fillSinexExample(), PrintCorStations(), and PrintCorStationsUniqueList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintPosUncertainty()

void dynadjust::networkadjust::dna_adjust::PrintPosUncertainty	(	std::ostream &	os,
		const UINT32 &	block,
		const UINT32 &	stn,
		const UINT32 &	mat_idx,
		const matrix_2d *	stationVariances,
		const UINT32 &	map_idx = 0,
		const vUINT32 *	blockStations = NULL )

private

Definition at line 10159 of file dnaadjust.cpp.

{
    double semimajor, semiminor, azimuth, hzPosU, vtPosU;
    UINT32 ic, jc;
 
    matrix_2d variances_cart(3, 3), variances_local(3, 3), mrotations(3, 3);
    matrix_2d *variances(&variances_cart);
 
    switch (projectSettings_.o._apu_vcv_units)
    {
    case ENU_apu_ui:
        variances = &variances_local;
        break;
    }
 
    // get cartesian matrix
    stationVariances->submatrix(mat_idx, mat_idx, &variances_cart, 3, 3);
 
    // Calculate standard deviations in local reference frame
    PropagateVariances_LocalCart<double>(variances_cart, variances_local, 
        bstBinaryRecords_.at(stn).currentLatitude, 
        bstBinaryRecords_.at(stn).currentLongitude, false,
        mrotations, true);
 
    // Compute error ellipse terms
    ErrorEllipseParameters<double>(variances_local, semimajor, semiminor, azimuth);
 
    // Compute positional uncertainty terms
    PositionalUncertainty<double>(semimajor, semiminor, sqrt(variances_local.get(2, 2)), hzPosU, vtPosU);
 
    // print...
    // station and padding
    os << std::setw(STATION) << std::left << bstBinaryRecords_.at(stn).stationName << std::setw(PAD2) << " ";
    
    os.flags(std::ios::fixed | std::ios::right);
 
    // latitude
    if (projectSettings_.o._angular_type_stn == DMS)
        os << std::setprecision(4+PRECISION_SEC_STN) << std::setw(LAT_EAST) <<
            RadtoDms(bstBinaryRecords_.at(stn).currentLatitude);
    else
        os << std::setprecision(4 + PRECISION_SEC_STN) << std::setw(LAT_EAST) <<
            Degrees(bstBinaryRecords_.at(stn).currentLatitude);
    // longitude
    if (projectSettings_.o._angular_type_stn == DMS)
        os << std::setprecision(4+PRECISION_SEC_STN) << std::setw(LON_NORTH) <<
            RadtoDmsL(bstBinaryRecords_.at(stn).currentLongitude);
    else
        os << std::setprecision(4 + PRECISION_SEC_STN) << std::setw(LON_NORTH) <<
            DegreesL(bstBinaryRecords_.at(stn).currentLongitude);
 
    // positional uncertainty 
    if (isAdjustmentQuestionable_)
        os << 
            StringFromTW(hzPosU, STAT, PRECISION_MTR_STN) <<
            StringFromTW(vtPosU, STAT, PRECISION_MTR_STN);
    else
        os << std::setprecision(PRECISION_MTR_STN) << std::setw(STAT) << hzPosU <<
            std::setprecision(PRECISION_MTR_STN) << std::fixed << std::right << std::setw(STAT) << vtPosU;
    
    // error ellipse semi-major, semi-minor, orientation
    os << std::setprecision(PRECISION_MTR_STN) << std::setw(PREC) << semimajor <<
        std::setprecision(PRECISION_MTR_STN) << std::setw(PREC) << semiminor <<
        std::setprecision(4) << std::setw(PREC) << RadtoDms(azimuth);
 
    os.flags(std::ios::scientific | std::ios::right);
 
    UINT16 PRECISION_UNCERTAINTY(9);
 
    // xx, xy, xz
    if (isAdjustmentQuestionable_)
        os << 
            StringFromTW(variances->get(0, 0), MSR, PRECISION_UNCERTAINTY) <<                        // e
            StringFromTW(variances->get(0, 1), MSR, PRECISION_UNCERTAINTY) <<                        // n
            StringFromTW(variances->get(0, 2), MSR, PRECISION_UNCERTAINTY) << std::endl;             // up
    else
        os << 
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(0, 0) <<                // e
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(0, 1) <<                // n
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(0, 2) << std::endl;     // up
    
    // Next line: yy, yz
    os << std::setw(STATION+PAD2+LAT_EAST+LON_NORTH+STAT+STAT+PREC+PREC+PREC+MSR) << " ";        // padding
    if (isAdjustmentQuestionable_)
        os << 
            StringFromTW(variances->get(1, 1), MSR, PRECISION_UNCERTAINTY) <<                        // n
            StringFromTW(variances->get(1, 2), MSR, PRECISION_UNCERTAINTY) << std::endl;                 // up
    else
        os << 
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(1, 1) <<                // n
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(1, 2) << std::endl;     // up
    
    // Next line: zz
    os << std::setw(STATION+PAD2+LAT_EAST+LON_NORTH+STAT+STAT+PREC+PREC+PREC+MSR+MSR) << " "; // padding
    if (isAdjustmentQuestionable_)
        os <<
            StringFromTW(variances->get(2, 2), MSR, PRECISION_UNCERTAINTY) << std::endl;     // up
    else
        os <<
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(2, 2) << std::endl;     // up
    
    if (!projectSettings_.o._output_pu_covariances)
        return;
 
    // Print covariances
    for (ic=map_idx+1; ic<v_blockStationsMap_.at(block).size(); ++ic)
    {
        jc = v_blockStationsMap_.at(block)[blockStations->at(ic)] * 3;
 
        // get cartesian submatrix corresponding to the covariance
        stationVariances->submatrix(mat_idx, jc, &variances_cart, 3, 3);
            
        switch (projectSettings_.o._apu_vcv_units)
        {
        case ENU_apu_ui:
            // Calculate vcv in local reference frame
            PropagateVariances_LocalCart<double>(variances_cart, variances_local, 
                bstBinaryRecords_.at(stn).currentLatitude, 
                bstBinaryRecords_.at(stn).currentLongitude, false,
                mrotations, false);
            break;
        }
 
        os << std::setw(STATION) << std::left << bstBinaryRecords_.at(blockStations->at(ic)).stationName;
            
        os.flags(std::ios::scientific | std::ios::right);
        os << 
            std::setw(PAD2+LAT_EAST+LON_NORTH+STAT+STAT+PREC+PREC+PREC) << " " <<                  // padding
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(0, 0) <<            // 11
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(0, 1) <<            // 12
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(0, 2) << std::endl; // 13
            
        os <<
            std::setw(STATION+PAD2+LAT_EAST+LON_NORTH+STAT+STAT+PREC+PREC+PREC) << " " <<           // padding
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(1, 0) <<            // 21
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(1, 1) <<            // 22
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(1, 2) << std::endl; // 23
        
        os <<
            std::setw(STATION+PAD2+LAT_EAST+LON_NORTH+STAT+STAT+PREC+PREC+PREC) << " " <<           // padding
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(2, 0) <<            // 31
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(2, 1) <<            // 32
            std::setprecision(PRECISION_UNCERTAINTY) << std::setw(MSR) << variances->get(2, 2) << std::endl; // 33
    }
}

References bstBinaryRecords_, Degrees(), DegreesL(), DMS, ENU_apu_ui, ErrorEllipseParameters(), dynadjust::math::matrix_2d::get(), isAdjustmentQuestionable_, LAT_EAST(), LON_NORTH(), MSR(), PAD2(), PositionalUncertainty(), PREC(), PRECISION_MTR_STN, PRECISION_SEC_STN, projectSettings_, PropagateVariances_LocalCart(), RadtoDms(), RadtoDmsL(), STAT(), STATION(), StringFromTW(), dynadjust::math::matrix_2d::submatrix(), and v_blockStationsMap_.

Referenced by fillSinexExample(), PrintPosUncertainties(), and PrintPosUncertaintiesUniqueList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintPosUncertainties()

void dynadjust::networkadjust::dna_adjust::PrintPosUncertainties	(	std::ostream &	os,
		const UINT32 &	block,
		const matrix_2d *	stationVariances )

private

Definition at line 10306 of file dnaadjust.cpp.

{
    vUINT32 v_blockStations(v_parameterStationList_.at(block));
 
    // if required, sort stations according to original station file order
    if (projectSettings_.o._sort_stn_file_order)
        SortStationsbyFileOrder(v_blockStations);
    
    switch (projectSettings_.a.adjust_mode)
    {
    case PhasedMode:
    case Phased_Block_1Mode:      // only the first block is rigorous
        os << "Block " << block + 1 << std::endl;
        break;
    }
 
    // Print header
    PrintPosUncertaintiesHeader(os);
 
    UINT32 mat_idx, stn;
 
    // Print stations according to the user-defined sort order
    for (UINT32 i=0; i<v_blockStationsMap_.at(block).size(); ++i)
    {
        stn = v_blockStations.at(i);
        mat_idx = v_blockStationsMap_.at(block)[stn] * 3;
 
        PrintPosUncertainty(os, //'\0', 
            block, stn, mat_idx,
            stationVariances, i, &v_blockStations);
    }
 
    os << std::endl;
 
    // return sort order to alpha-numeric
    if (projectSettings_.o._sort_stn_file_order)
        SortStationsbyID(v_blockStations);
}

References Phased_Block_1Mode, PhasedMode, PrintPosUncertaintiesHeader(), PrintPosUncertainty(), projectSettings_, SortStationsbyFileOrder(), SortStationsbyID(), v_blockStationsMap_, and v_parameterStationList_.

Referenced by fillSinexExample(), and PrintPositionalUncertainty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintPosUncertaintiesUniqueList()

void dynadjust::networkadjust::dna_adjust::PrintPosUncertaintiesUniqueList	(	std::ostream &	os,
		const v_mat_2d *	stationVariances )

private

Definition at line 10068 of file dnaadjust.cpp.

{
    // Print header
    PrintPosUncertaintiesHeader(os);
 
    UINT32 block(UINT_MAX), stn, mat_index;
    _it_u32u32_uint32_pair _it_bsmu;
 
    // Determine sort order of block Stations Map
    if (projectSettings_.a.stage || projectSettings_.a.adjust_mode == Phased_Block_1Mode)
    {
        // sort by blocks to create efficiency when deserialising matrix info
        std::sort(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end(), 
            CompareBlockStationMapUnique_byBlock<u32u32_uint32_pair>());
    }
    else if (projectSettings_.o._sort_stn_file_order)
    {
        CompareBlockStationMapUnique_byFileOrder<station_t, u32u32_uint32_pair> stnorderCompareFunc(&bstBinaryRecords_);
        std::sort(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end(), stnorderCompareFunc);
    }
    else
        std::sort(v_blockStationsMapUnique_.begin(), v_blockStationsMapUnique_.end());
    
    std::stringstream stationRecord;
    v_uint32_string_pair stationsOutput;
    stationsOutput.reserve(v_blockStationsMapUnique_.size());
 
    std::ostream* outstream(&os);
    if (projectSettings_.a.stage)
        outstream = &stationRecord;
 
    // Print stations according to the user-defined sort order
    for (_it_bsmu=v_blockStationsMapUnique_.begin();
        _it_bsmu!=v_blockStationsMapUnique_.end(); ++_it_bsmu)
    {
        // If this is not the first block, exit if block-1 mode
        if (projectSettings_.a.adjust_mode == Phased_Block_1Mode)
            if (_it_bsmu->second > 0)
                break;
 
        if (projectSettings_.a.stage)
        {
            if (block != _it_bsmu->second)
            {
                // unload previous block
                if (_it_bsmu->second > 0)
                    UnloadBlock(_it_bsmu->second-1, 1, 
                        sf_rigorous_vars);
                // load up this block
                if (projectSettings_.a.stage)
                    DeserialiseBlockFromMappedFile(_it_bsmu->second, 1, 
                        sf_rigorous_vars);
            }
        }
 
        block = _it_bsmu->second;
        stn = _it_bsmu->first.first;
        mat_index = _it_bsmu->first.second * 3;
 
        PrintPosUncertainty(*outstream,
            block, stn, mat_index, 
                &stationVariances->at(block));
 
        if (projectSettings_.a.stage)
        {
            stationsOutput.push_back(uint32_string_pair(stn, stationRecord.str()));
            stationRecord.str("");
        }
    }
 
    if (projectSettings_.a.stage)
    {
        UnloadBlock(block, 1, sf_rigorous_vars);
 
        // if required, sort stations according to original station file order
        if (projectSettings_.o._sort_stn_file_order)
        {
            CompareOddPairFirst_FileOrder<station_t, UINT32, std::string> stnorderCompareFunc(&bstBinaryRecords_);
            std::sort(stationsOutput.begin(), stationsOutput.end(), stnorderCompareFunc);
        }
        else
            std::sort(stationsOutput.begin(), stationsOutput.end(), CompareOddPairFirst<UINT32, std::string>());
 
        for_each(stationsOutput.begin(), stationsOutput.end(),
            [&stationsOutput, &os] (std::pair<UINT32, std::string>& posRecord) { 
                os << posRecord.second;
            }
        );
    }
}

References bstBinaryRecords_, DeserialiseBlockFromMappedFile(), Phased_Block_1Mode, PrintPosUncertaintiesHeader(), PrintPosUncertainty(), projectSettings_, sf_rigorous_vars, UnloadBlock(), and v_blockStationsMapUnique_.

Referenced by fillSinexExample(), and PrintPositionalUncertainty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintPosUncertaintiesHeader()

void dynadjust::networkadjust::dna_adjust::PrintPosUncertaintiesHeader ( std::ostream & os )

private

Definition at line 10031 of file dnaadjust.cpp.

{
    os << std::setw(STATION) << std::left << "Station" <<
        std::setw(PAD2) << " " << 
        std::right << std::setw(LAT_EAST) << CDnaStation::CoordinateName('P') << 
        std::right << std::setw(LON_NORTH) << CDnaStation::CoordinateName('L') << 
        std::right << std::setw(STAT) << "Hz PosU" << 
        std::right << std::setw(STAT) << "Vt PosU" << 
        std::right << std::setw(PREC) << "Semi-major" << 
        std::right << std::setw(PREC) << "Semi-minor" << 
        std::right << std::setw(PREC) << "Orientation";
 
    switch (projectSettings_.o._apu_vcv_units)
    {
    case ENU_apu_ui:
        os <<  
            std::right << std::setw(MSR) << "Variance(e)" << 
            std::right << std::setw(MSR) << "Variance(n)" << 
            std::right << std::setw(MSR) << "Variance(up)" << std::endl;
        break;
    case XYZ_apu_ui:
    default:
        os <<  
            std::right << std::setw(MSR) << "Variance(X)" << 
            std::right << std::setw(MSR) << "Variance(Y)" << 
            std::right << std::setw(MSR) << "Variance(Z)" << std::endl;
        break;
    }
 
    UINT32 i, j = STATION+PAD2+LAT_EAST+LON_NORTH+STAT+STAT+PREC+PREC+PREC+MSR+MSR+MSR;
 
    for (i=0; i<j; ++i)
        os << "-";
    os << std::endl;
}

References dynadjust::measurements::CDnaStation::CoordinateName(), ENU_apu_ui, LAT_EAST(), LON_NORTH(), MSR(), PAD2(), PREC(), projectSettings_, STAT(), STATION(), and XYZ_apu_ui.

Referenced by fillSinexExample(), PrintPosUncertainties(), and PrintPosUncertaintiesUniqueList().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateGeographicCoordsPhased()

void dynadjust::networkadjust::dna_adjust::UpdateGeographicCoordsPhased	(	const UINT32 &	block,
		matrix_2d *	estimatedStations )

private

Definition at line 10500 of file dnaadjust.cpp.

{
    UINT32 i(0), j(0);
    vUINT32 v_blockStations(v_parameterStationList_.at(block));
    it_vstn_appear _it_appear(v_paramStnAppearance_.at(block).begin());
 
    for (j=0, i=0; i<estimatedStations->rows(); j++, i+=3, ++_it_appear)
    {
        // The same station may appear in several blocks.  So, only
        // update (once) when this is the first time this station 
        // appears
        if (!_it_appear->first_appearance_fwd)
            continue;
 
        CartToGeo<double>(estimatedStations->get(i, 0), estimatedStations->get(i+1, 0), estimatedStations->get(i+2, 0),
            &(bstBinaryRecords_.at(v_blockStations.at(j)).currentLatitude), 
            &(bstBinaryRecords_.at(v_blockStations.at(j)).currentLongitude), 
            &(bstBinaryRecords_.at(v_blockStations.at(j)).currentHeight), 
            datum_.GetEllipsoidRef());
    }
}

References bstBinaryRecords_, CartToGeo(), datum_, dynadjust::math::matrix_2d::get(), dynadjust::math::matrix_2d::rows(), v_parameterStationList_, and v_paramStnAppearance_.

Referenced by fillSinexExample(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateGeographicCoords()

void dynadjust::networkadjust::dna_adjust::UpdateGeographicCoords ( )

private

Definition at line 10523 of file dnaadjust.cpp.

{
    it_vUINT32 _it_stn;
    UINT32 stn(0);
    
    // all stations in simultaneous mode are kept in ISL
    for (_it_stn=v_ISL_.at(0).begin(); _it_stn!=v_ISL_.at(0).end(); ++_it_stn, stn+=3)
    {
        CartToGeo<double>(v_estimatedStations_.at(0).get(stn, 0), v_estimatedStations_.at(0).get(stn+1, 0), v_estimatedStations_.at(0).get(stn+2, 0),
            &(bstBinaryRecords_.at(*_it_stn).currentLatitude), 
            &(bstBinaryRecords_.at(*_it_stn).currentLongitude), 
            &(bstBinaryRecords_.at(*_it_stn).currentHeight), 
            datum_.GetEllipsoidRef());
    }
}

References bstBinaryRecords_, CartToGeo(), datum_, v_estimatedStations_, and v_ISL_.

Referenced by fillSinexExample(), and UpdateAdjustment().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBlkMatrixElemStn1()

UINT32 dynadjust::networkadjust::dna_adjust::GetBlkMatrixElemStn1	(	const UINT32 &	block,
		const pit_vmsr_t	_it_msr )

inlineprivate

Definition at line 1059 of file dnaadjust.hpp.

                                                                        {
        return v_blockStationsMap_.at(block)[(*_it_msr)->station1] * 3;
    }

References v_blockStationsMap_.

Here is the caller graph for this function:

◆ GetBlkMatrixElemStn2()

UINT32 dynadjust::networkadjust::dna_adjust::GetBlkMatrixElemStn2	(	const UINT32 &	block,
		const pit_vmsr_t	_it_msr )

inlineprivate

Definition at line 1063 of file dnaadjust.hpp.

                                                                        {
        return v_blockStationsMap_.at(block)[(*_it_msr)->station2] * 3;
    }

References v_blockStationsMap_.

Here is the caller graph for this function:

◆ GetBlkMatrixElemStn3()

UINT32 dynadjust::networkadjust::dna_adjust::GetBlkMatrixElemStn3	(	const UINT32 &	block,
		const pit_vmsr_t	_it_msr )

inlineprivate

Definition at line 1067 of file dnaadjust.hpp.

                                                                        {
        return v_blockStationsMap_.at(block)[(*_it_msr)->station3] * 3;
    }

References v_blockStationsMap_.

Referenced by ComputePrecisionAdjMsrs(), UpdateDesignNormalMeasMatrices_A(), UpdateIgnoredMeasurements_A(), and UpdateNormals().

Here is the caller graph for this function:

◆ debug_BlockInformation()

void dynadjust::networkadjust::dna_adjust::debug_BlockInformation	(	const UINT32 &	currentBlock,
		const std::string &	adjustment_method )

private

Definition at line 4388 of file dnaadjust.cpp.

{
    if (projectSettings_.g.verbose > 3)
    {
        it_vUINT32 _it_stn;
        for (UINT32 i=0; i<v_parameterStationList_.at(currentBlock).size(); ++i)
        {
            debug_file << bstBinaryRecords_.at(v_parameterStationList_.at(currentBlock).at(i)).stationName;
            if ((_it_stn = find(v_ISL_.at(currentBlock).begin(), v_ISL_.at(currentBlock).end(), v_parameterStationList_.at(currentBlock).at(i))) != v_ISL_.at(currentBlock).end())
                debug_file << "i ";
            else if ((_it_stn = find(v_JSL_.at(currentBlock).begin(), v_JSL_.at(currentBlock).end(), v_parameterStationList_.at(currentBlock).at(i))) != v_JSL_.at(currentBlock).end())
                debug_file << "j ";
            else 
                debug_file << " ";                
        }
        debug_file << std::endl;
 
        debug_file << "Block " << currentBlock + 1 << " " << adjustment_method << std::endl;
        debug_file << "Adjustment Estimates " << std::fixed << std::setprecision(16) << v_estimatedStations_.at(currentBlock);
    }
}

References bstBinaryRecords_, debug_file, projectSettings_, v_estimatedStations_, v_ISL_, v_JSL_, and v_parameterStationList_.

Referenced by AdjustPhasedForward(), AdjustPhasedReverse(), and AdjustPhasedReverseCombine().

Here is the caller graph for this function:

◆ debug_SolutionInformation()

void dynadjust::networkadjust::dna_adjust::debug_SolutionInformation ( const UINT32 & currentBlock )

private

Definition at line 4350 of file dnaadjust.cpp.

{
    if (projectSettings_.g.verbose > 0)
    {
        debug_file << "Block " << currentBlock + 1;
        if (projectSettings_.a.adjust_mode != SimultaneousMode)
            debug_file << (forward_ ? " (Forward)" : " (Reverse)");
        debug_file << std::endl;
        debug_file << "Pre-adjustment Estimates " << std::fixed << std::setprecision(16) << v_estimatedStations_.at(currentBlock);
 
        debug_file << "Block " << currentBlock + 1;
        if (projectSettings_.a.adjust_mode != SimultaneousMode)
            debug_file << (forward_ ? " (Forward)" : " (Reverse)");
        debug_file << std::endl;
        debug_file << "Design " << std::fixed << std::setprecision(16) << v_design_.at(currentBlock);
 
        debug_file << "Block " << currentBlock + 1;
        if (projectSettings_.a.adjust_mode != SimultaneousMode)
            debug_file << (forward_ ? " (Forward)" : " (Reverse)");
        debug_file << std::endl;
        debug_file << "Measurements " << std::fixed << std::setprecision(16) << v_measMinusComp_.at(currentBlock);
 
        debug_file << "Block " << currentBlock + 1;
        if (projectSettings_.a.adjust_mode != SimultaneousMode)
            debug_file << (forward_ ? " (Forward)" : " (Reverse)");
        debug_file << std::endl;
        debug_file << "At * V-inv " << std::fixed << std::setprecision(16) << v_AtVinv_.at(currentBlock) << std::endl;
 
        debug_file << "Block " << currentBlock + 1;
        if (projectSettings_.a.adjust_mode != SimultaneousMode)
            debug_file << (forward_ ? " (Forward)" : " (Reverse)");
        debug_file << std::endl;
        debug_file << "Normals " << std::fixed << std::setprecision(16) << v_normals_.at(currentBlock) << std::endl;
        debug_file.flush();
    }
}

References debug_file, forward_, projectSettings_, SimultaneousMode, v_AtVinv_, v_design_, v_estimatedStations_, v_measMinusComp_, and v_normals_.

Referenced by Solve(), and SolveTry().

Here is the caller graph for this function:

◆ BuildUniqueBlockStationMap()

void dynadjust::networkadjust::dna_adjust::BuildUniqueBlockStationMap ( )

private

Definition at line 2028 of file dnaadjust.cpp.

{
    v_blockStationsMapUnique_.reserve(bstBinaryRecords_.size());
    it_vvstn_appear _it_va(v_paramStnAppearance_.begin());
    it_vstn_appear _it_a;
 
    it_v_uint32_uint32_map _it_vm(v_blockStationsMap_.begin());
    it_uint32_uint32_map _it_m;
    
    // for each block
    for (_it_vm=v_blockStationsMap_.begin(), _it_va=v_paramStnAppearance_.begin(); 
        _it_vm!=v_blockStationsMap_.end(); 
        ++_it_vm, ++_it_va)
    {
        // for each station
        for (_it_m=_it_vm->begin(), _it_a=_it_va->begin(); 
            _it_m!=_it_vm->end(); 
            ++_it_m, ++_it_a)
        {
            if (_it_a->first_appearance_fwd)
            {
                v_blockStationsMapUnique_.push_back(
                    u32u32_uint32_pair(
                        uint32_uint32_pair(_it_m->first, _it_m->second),  // station, block index
                        static_cast<UINT32>(std::distance(v_blockStationsMap_.begin(), _it_vm)))); // block
            }           
        }
    }
}

References bstBinaryRecords_, v_blockStationsMap_, v_blockStationsMapUnique_, and v_paramStnAppearance_.

Referenced by PrepareAdjustment().

Here is the caller graph for this function:

◆ BuildSimultaneousStnAppearance()

void dynadjust::networkadjust::dna_adjust::BuildSimultaneousStnAppearance ( )

private

Definition at line 2013 of file dnaadjust.cpp.

{
    it_vstn_appear _it_appear;
 
    v_paramStnAppearance_.resize(1);
    v_paramStnAppearance_.at(0).resize(v_blockStationsMap_.at(0).size());
 
    UINT32 stn(0);
    for_each(v_paramStnAppearance_.at(0).begin(), v_paramStnAppearance_.at(0).end(),
        [&stn](stn_appear& appear) {
            appear.set_id(stn++);
            appear.first_fwd();
    });
}

References v_blockStationsMap_, and v_paramStnAppearance_.

Referenced by PrepareAdjustment().

Here is the caller graph for this function:

◆ OpenStageFileStreams()

void dynadjust::networkadjust::dna_adjust::OpenStageFileStreams	(	const int	file_count = 0,
			... )

private

Definition at line 384 of file dnaadjust-stage.cpp.

{
    if (file_count == 0)
    {
        // serialise all.  That is, call this function again, but with 
        // arguments for all files
        OpenStageFileStreams(12, 
            sf_normals_r, sf_meas_minus_comp,
            sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
            sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
            sf_rigorous_vars, sf_prec_adj_msrs, sf_corrections);
        return;
    }
 
    std::stringstream ss;
    ss << projectSettings_.g.output_folder << FOLDER_SLASH << projectSettings_.g.network_name << "-";
    std::string filePath(ss.str());
 
    v_stageFileStreams_.clear();
    std::string fullfilePath;
 
    va_list vlist;
    va_start(vlist, file_count);
    
    try {       
 
        for (UINT16 file(0); file<file_count; ++file)
        {
            switch (va_arg(vlist, int))
            {
            case sf_normals_r:
        
                // Normals - reverse
                fullfilePath = filePath + "neqr.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_normalsR_, fullfilePath, std::ios::out | std::ios::binary, binary);
                normalsR_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
            
                break;
            case sf_meas_minus_comp:
 
                // Measured minus computed
                fullfilePath = filePath + "mmc.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_measMinusComp_, fullfilePath, std::ios::out | std::ios::binary, binary);
                measMinusComp_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
        
                break;
            case sf_estimated_stns:
 
                // Estimated stations
                fullfilePath = filePath + "est.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_estimatedStations_, fullfilePath, std::ios::out | std::ios::binary, binary);
                estimatedStations_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            case sf_original_stns:
 
                // Original stations
                fullfilePath = filePath + "ost.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_originalStations_, fullfilePath, std::ios::out | std::ios::binary, binary);
                originalStations_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            case sf_rigorous_stns:
 
                // Rigorous stations
                fullfilePath = filePath + "rst.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_rigorousStations_, fullfilePath, std::ios::out | std::ios::binary, binary);
                rigorousStations_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            case sf_junction_vars:
 
                // Junction variances
                fullfilePath = filePath + "jva.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_junctionVariances_, fullfilePath, std::ios::out | std::ios::binary, binary);
                junctionVariances_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            case sf_junction_vars_f:
 
                // Junction variances forward
                fullfilePath = filePath + "jvf.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_junctionVariancesFwd_, fullfilePath, std::ios::out | std::ios::binary, binary);
                junctionVariancesFwd_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            case sf_junction_ests_f:
 
                // Junction estimates forward
                fullfilePath = filePath + "jef.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_junctionEstimatesFwd_, fullfilePath, std::ios::out | std::ios::binary, binary);
                junctionEstimatesFwd_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            case sf_junction_ests_r:
 
                // Junction estimates reverse
                fullfilePath = filePath + "jer.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_junctionEstimatesRev_, fullfilePath, std::ios::out | std::ios::binary, binary);
                junctionEstimatesRev_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            case sf_rigorous_vars:
 
                // Rigorous variances
                fullfilePath = filePath + "rva.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_rigorousVariances_, fullfilePath, std::ios::out | std::ios::binary, binary);
                rigorousVariances_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            case sf_prec_adj_msrs:
 
                // Precision adjusted measurements
                fullfilePath = filePath + "pam.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_precAdjMsrs_, fullfilePath, std::ios::out | std::ios::binary, binary);
                precAdjMsrs_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            case sf_corrections:
 
                // Corrections
                fullfilePath = filePath + "cor.mtx";
                v_stageFileStreams_.push_back(fullfilePath);
                if (projectSettings_.a.recreate_stage_files)
                    file_opener(f_corrections_, fullfilePath, std::ios::out | std::ios::binary, binary);
                corrections_map_.setnewFilePath(fullfilePath, projectSettings_.a.purge_stage_files);
 
                break;
            }
        }
        va_end(vlist);
    }
    catch (const std::runtime_error& e) {
        va_end(vlist);
        SignalExceptionAdjustment(e.what(), 0);
    }
}

References binary, corrections_map_, estimatedStations_map_, f_corrections_, f_estimatedStations_, f_junctionEstimatesFwd_, f_junctionEstimatesRev_, f_junctionVariances_, f_junctionVariancesFwd_, f_measMinusComp_, f_normalsR_, f_originalStations_, f_precAdjMsrs_, f_rigorousStations_, f_rigorousVariances_, file_opener(), junctionEstimatesFwd_map_, junctionEstimatesRev_map_, junctionVariances_map_, junctionVariancesFwd_map_, measMinusComp_map_, normalsR_map_, OpenStageFileStreams(), originalStations_map_, precAdjMsrs_map_, projectSettings_, rigorousStations_map_, rigorousVariances_map_, sf_corrections, sf_estimated_stns, sf_junction_ests_f, sf_junction_ests_r, sf_junction_vars, sf_junction_vars_f, sf_meas_minus_comp, sf_normals_r, sf_original_stns, sf_prec_adj_msrs, sf_rigorous_stns, sf_rigorous_vars, SignalExceptionAdjustment(), and v_stageFileStreams_.

Referenced by DeSerialiseAdjustedVarianceMatrices(), OpenOutputFileStreams(), OpenStageFileStreams(), and SerialiseAdjustedVarianceMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReserveBlockMapRegions()

void dynadjust::networkadjust::dna_adjust::ReserveBlockMapRegions	(	const int	file_count = 0,
			... )

private

Definition at line 321 of file dnaadjust-stage.cpp.

{
    if (file_count == 0)
    {
        // serialise all.  That is, call this function again, but with 
        // arguments for all files
        ReserveBlockMapRegions(12, 
            sf_normals_r, sf_meas_minus_comp,
            sf_estimated_stns, sf_original_stns, sf_rigorous_stns,
            sf_junction_vars, sf_junction_vars_f, sf_junction_ests_f, sf_junction_ests_r,
            sf_rigorous_vars, sf_prec_adj_msrs, sf_corrections);
        return;
    }
 
    va_list vlist;
    va_start(vlist, file_count);
 
    for (UINT16 file(0); file<file_count; ++file)
    {
        switch (va_arg(vlist, int))
        {
        case sf_normals_r:
            normalsR_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_meas_minus_comp:
            measMinusComp_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_estimated_stns:
            estimatedStations_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_original_stns:
            originalStations_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_rigorous_stns:
            rigorousStations_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_junction_vars:
            junctionVariances_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_junction_vars_f:
            junctionVariancesFwd_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_junction_ests_f:
            junctionEstimatesFwd_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_junction_ests_r:
            junctionEstimatesRev_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_rigorous_vars:
            rigorousVariances_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_prec_adj_msrs:
            precAdjMsrs_map_.reserveblockMapRegions(blockCount_);
            break;
        case sf_corrections:
            corrections_map_.reserveblockMapRegions(blockCount_);
            break;
        }
    }
    va_end(vlist);
}

References blockCount_, corrections_map_, estimatedStations_map_, junctionEstimatesFwd_map_, junctionEstimatesRev_map_, junctionVariances_map_, junctionVariancesFwd_map_, measMinusComp_map_, normalsR_map_, originalStations_map_, precAdjMsrs_map_, ReserveBlockMapRegions(), rigorousStations_map_, rigorousVariances_map_, sf_corrections, sf_estimated_stns, sf_junction_ests_f, sf_junction_ests_r, sf_junction_vars, sf_junction_vars_f, sf_meas_minus_comp, sf_normals_r, sf_original_stns, sf_prec_adj_msrs, sf_rigorous_stns, and sf_rigorous_vars.

Referenced by DeSerialiseAdjustedVarianceMatrices(), OpenOutputFileStreams(), ReserveBlockMapRegions(), and SerialiseAdjustedVarianceMatrices().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CloseStageFileStreams()

void dynadjust::networkadjust::dna_adjust::CloseStageFileStreams ( )

private

Definition at line 970 of file dnaadjust-stage.cpp.

{
    // Normals -- reverse
    f_normalsR_.close();
 
    // Measured minus computed
    f_measMinusComp_.close();
 
    // Estimated stations
    f_estimatedStations_.close();
 
    // Original stations
    f_originalStations_.close();
 
    // Rigorous stations
    f_rigorousStations_.close();
 
    // Junction variances
    f_junctionVariances_.close();
 
    // Junction variances forward
    f_junctionVariancesFwd_.close();
 
    // Junction estimates forward
    f_junctionEstimatesFwd_.close();
 
    // Junction estimates reverse
    f_junctionEstimatesRev_.close();
 
    // Rigorous variances
    f_rigorousVariances_.close();
 
    // Precision adjusted measurements
    f_precAdjMsrs_.close();
 
    // Corrections
    f_corrections_.close();
 
}

References f_corrections_, f_estimatedStations_, f_junctionEstimatesFwd_, f_junctionEstimatesRev_, f_junctionVariances_, f_junctionVariancesFwd_, f_measMinusComp_, f_normalsR_, f_originalStations_, f_precAdjMsrs_, f_rigorousStations_, and f_rigorousVariances_.

Referenced by PrepareAdjustment().

Here is the caller graph for this function:

◆ LoadDatabaseId()

void dynadjust::networkadjust::dna_adjust::LoadDatabaseId ( )

private

Definition at line 2447 of file dnaadjust.cpp.

{
    if (!projectSettings_.o._database_ids)
        return;
 
    if (databaseIDsLoaded_)
        return;
 
    std::string dbid_filename = formPath<std::string>(projectSettings_.g.output_folder,
        projectSettings_.g.network_name, "dbid");
 
    // When printing database ids, force printing adjusted measurements 
    // as a contiguous list in original sort order.  Why?  To simplify 
    // reading adj file when loading adjusted measurement info to
    // the database.
    projectSettings_.o._output_msr_blocks = 0;
    
    // Do not print computed measurements
    //projectSettings_.o._cmp_msr_iteration = 0;
    
    v_msr_db_map_.clear();
    
    std::ifstream dbid_file;
    try {
        // Create geoid file.  Throws runtime_error on failure.
        file_opener(dbid_file, dbid_filename,
            std::ios::in | std::ios::binary, binary);
    }
    catch (const std::runtime_error& e) {
        SignalExceptionAdjustment(e.what(), 0);
    }
    
    UINT32 r, recordCount;
    msr_database_id_map rec;
    
    try {
        // get size and reserve vector size
        dbid_file.read(reinterpret_cast<char *>(&recordCount), sizeof(UINT32));
        v_msr_db_map_.reserve(recordCount);
        
        UINT16 val;
 
        for (r = 0; r < recordCount; r++)
        {
            // Read data
            dbid_file.read(reinterpret_cast<char *>(&rec.msr_id), sizeof(UINT32));
            dbid_file.read(reinterpret_cast<char *>(&rec.cluster_id), sizeof(UINT32));
            dbid_file.read(reinterpret_cast<char *>(&val), sizeof(UINT16));
            rec.is_msr_id_set = val_uint<bool, UINT16>(val);
            dbid_file.read(reinterpret_cast<char *>(&val), sizeof(UINT16));
            rec.is_cls_id_set = val_uint<bool, UINT16>(val);
            
            // push back
            v_msr_db_map_.push_back(rec);
        }
 
        dbid_file.close();
        databaseIDsLoaded_ = true;
    }
    catch (const std::ifstream::failure& f) {
        SignalExceptionAdjustment(f.what(), 0);
    }
    catch (const XMLInteropException& e)  {
        SignalExceptionAdjustment(e.what(), 0);
    }
}

References binary, msr_database_t::cluster_id, databaseIDsLoaded_, file_opener(), formPath(), msr_database_t::is_cls_id_set, msr_database_t::is_msr_id_set, msr_database_t::msr_id, projectSettings_, SignalExceptionAdjustment(), v_msr_db_map_, and val_uint().

Referenced by AdjustNetwork(), and PrintAdjustedNetworkMeasurements().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ concurrent_adj_ofstream

concurrent_ofstream<std::string> dynadjust::networkadjust::dna_adjust::concurrent_adj_ofstream

Definition at line 346 of file dnaadjust.hpp.

Referenced by ThreadSafeWritetoAdjFile(), and ThreadSafeWritetoDbgFile().

◆ isPreparing_

bool dynadjust::networkadjust::dna_adjust::isPreparing_

Definition at line 370 of file dnaadjust.hpp.

Referenced by dna_adjust(), IsPreparing(), PrepareAdjustment(), SignalExceptionAdjustment(), and UpdateAdjustment().

◆ isAdjusting_

bool dynadjust::networkadjust::dna_adjust::isAdjusting_

Definition at line 371 of file dnaadjust.hpp.

Referenced by AdjustNetwork(), AdjustPhasedMultiThread(), dna_adjust(), IsAdjusting(), PrepareAdjustment(), SignalExceptionAdjustment(), and ValidateandFinaliseAdjustment().

◆ isCombining_

bool dynadjust::networkadjust::dna_adjust::isCombining_

Definition at line 372 of file dnaadjust.hpp.

Referenced by AdjustPhasedReverse(), AdjustPhasedReverseCombine(), dna_adjust(), PrepareAdjustment(), processingCombine(), and SignalExceptionAdjustment().

◆ forward_

bool dynadjust::networkadjust::dna_adjust::forward_

Definition at line 373 of file dnaadjust.hpp.

Referenced by AdjustPhasedForward(), AdjustPhasedReverse(), AdjustPhasedReverseCombine(), debug_SolutionInformation(), dna_adjust(), PrintAdjMeasurements(), processingForward(), and Solve().

◆ isFirstTimeAdjustment_

bool dynadjust::networkadjust::dna_adjust::isFirstTimeAdjustment_

Definition at line 374 of file dnaadjust.hpp.

Referenced by dna_adjust(), and PrepareAdjustment().

◆ isIterationComplete_

bool dynadjust::networkadjust::dna_adjust::isIterationComplete_

Definition at line 375 of file dnaadjust.hpp.

Referenced by AdjustNetwork(), AdjustPhased(), AdjustSimultaneous(), dna_adjust(), and PrintAdjMeasurements().

◆ isAdjustmentQuestionable_

bool dynadjust::networkadjust::dna_adjust::isAdjustmentQuestionable_

Definition at line 376 of file dnaadjust.hpp.

Referenced by AdjustNetwork(), ComputeAdjMsrBlockOnIteration(), dna_adjust(), GenerateStatistics(), PrintAdjMeasurementStatistics(), PrintAdjStation(), PrintCompMeasurementsLinear(), PrintCorStation(), PrintMeasurementsAngular(), PrintMeasurementsLinear(), and PrintPosUncertainty().

◆ blockCount_

UINT32 dynadjust::networkadjust::dna_adjust::blockCount_

Definition at line 378 of file dnaadjust.hpp.

Referenced by AdjustPhasedForward(), AdjustPhasedMultiThread(), AdjustPhasedReverse(), AdjustPhasedReverseCombine(), blockCount(), CombinationThreadRequired(), ComputeAdjustedMsrPrecisions(), ComputeandPrintAdjMsrOnIteration(), ComputeChiSquareNetwork(), ComputeGlobalPelzer(), ComputeTstatistics(), DeSerialiseAdjustedVarianceMatrices(), dna_adjust(), GetMemoryFootprint(), InitialiseAdjustment(), LoadSegmentationFile(), LoadSegmentationFileParameters(), LoadSegmentationMetrics(), PrepareAdjustment(), PrintAdjustedNetworkMeasurements(), PrintAdjustedNetworkStations(), PrintEstimatedStationCoordinatestoDNAXML_Y(), PrintEstimatedStationCoordinatestoSNX(), PrintNetworkStationCorrections(), PrintPositionalUncertainty(), ReserveBlockMapRegions(), ResizeMatrixVectors(), SerialiseAdjustedVarianceMatrices(), UpdateAdjustment(), and UpdateEstimatesFinalNoCombine().

◆ currentBlock_

UINT32 dynadjust::networkadjust::dna_adjust::currentBlock_

Definition at line 379 of file dnaadjust.hpp.

Referenced by CurrentBlock(), dna_adjust(), InitialiseAdjustment(), PrepareAdjustment(), and SetcurrentBlock().

◆ total_time_

boost::posix_time::milliseconds dynadjust::networkadjust::dna_adjust::total_time_

Definition at line 381 of file dnaadjust.hpp.

Referenced by adjustTime(), dna_adjust(), and PrintAdjustmentTime().

◆ adjustStatus_

_ADJUST_STATUS_ dynadjust::networkadjust::dna_adjust::adjustStatus_

Definition at line 382 of file dnaadjust.hpp.

Referenced by AdjustNetwork(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), dna_adjust(), ExceptionRaised(), GenerateStatistics(), GetStatus(), InitialiseAdjustment(), PrintAdjustedNetworkMeasurements(), PrintAdjustmentStatus(), SignalExceptionAdjustment(), ValidateandFinaliseAdjustment(), and ~dna_adjust().

◆ statusMessages_

vstring dynadjust::networkadjust::dna_adjust::statusMessages_

Definition at line 383 of file dnaadjust.hpp.

Referenced by dna_adjust(), and InitialiseAdjustment().

◆ currentIteration_

UINT32 dynadjust::networkadjust::dna_adjust::currentIteration_

Definition at line 384 of file dnaadjust.hpp.

Referenced by CurrentIteration(), dna_adjust(), incrementIteration(), and initialiseIteration().

◆ v_blockMeta_

std::vector<blockMeta_t> dynadjust::networkadjust::dna_adjust::v_blockMeta_

◆ datum_

CDnaDatum dynadjust::networkadjust::dna_adjust::datum_

private

Definition at line 1075 of file dnaadjust.hpp.

Referenced by dna_adjust(), LoadVarianceMatrix_G(), LoadVarianceMatrix_X(), LoadVarianceMatrix_Y(), PopulateEstimatedStationMatrix(), PrintAdjMeasurements_YLLH(), PrintAdjStation(), PrintCompMeasurements_YLLH(), PrintEstimatedStationCoordinatestoDNAXML(), PrintEstimatedStationCoordinatestoDNAXML_Y(), PrintEstimatedStationCoordinatestoSNX(), PrintOutputFileHeaderInfo(), ReduceYLLHMeasurementsforPrinting(), SetDefaultReferenceFrame(), UpdateDesignNormalMeasMatrices_CEM(), UpdateDesignNormalMeasMatrices_E(), UpdateDesignNormalMeasMatrices_HR(), UpdateDesignNormalMeasMatrices_IP(), UpdateDesignNormalMeasMatrices_L(), UpdateDesignNormalMeasMatrices_M(), UpdateDesignNormalMeasMatrices_Y(), UpdateGeographicCoords(), UpdateGeographicCoordsPhased(), UpdateIgnoredMeasurements_CEM(), UpdateIgnoredMeasurements_E(), UpdateIgnoredMeasurements_HR(), UpdateIgnoredMeasurements_IP(), UpdateIgnoredMeasurements_JQ(), UpdateIgnoredMeasurements_L(), UpdateIgnoredMeasurements_M(), UpdateIgnoredMeasurements_Y(), and UpdateMsrRecord().

◆ projection_

CDnaProjection dynadjust::networkadjust::dna_adjust::projection_

private

Definition at line 1076 of file dnaadjust.hpp.

Referenced by PrintAdjStation().

◆ _var_C

double dynadjust::networkadjust::dna_adjust::_var_C

private

Definition at line 1077 of file dnaadjust.hpp.

Referenced by FormConstraintStationVarianceMatrix(), and InitialiseAdjustment().

◆ _var_F

double dynadjust::networkadjust::dna_adjust::_var_F

private

Definition at line 1077 of file dnaadjust.hpp.

Referenced by FormConstraintStationVarianceMatrix(), and InitialiseAdjustment().

◆ _inv_var_cart_c

matrix_2d dynadjust::networkadjust::dna_adjust::_inv_var_cart_c

private

Definition at line 1078 of file dnaadjust.hpp.

Referenced by FormConstraintStationVarianceMatrix(), and InitialiseAdjustment().

◆ _inv_var_cart_f

matrix_2d dynadjust::networkadjust::dna_adjust::_inv_var_cart_f

private

Definition at line 1078 of file dnaadjust.hpp.

Referenced by FormConstraintStationVarianceMatrix(), and InitialiseAdjustment().

◆ projectSettings_

project_settings dynadjust::networkadjust::dna_adjust::projectSettings_

private

Definition at line 1080 of file dnaadjust.hpp.

Referenced by AddConstraintStationstoNormalsForward(), AddConstraintStationstoNormalsSimultaneous(), AddMsrtoMeasMinusComp(), AdjustNetwork(), AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedForward(), AdjustPhasedMultiThread(), AdjustPhasedReverse(), AdjustPhasedReverseCombine(), AdjustSimultaneous(), ApplyAdditionalConstraints(), CarryForwardJunctions(), CarryReverseJunctions(), CarryStnEstimatesandVariancesCombine(), CarryStnEstimatesandVariancesForward(), CarryStnEstimatesandVariancesReverse(), CloseOutputFiles(), ComputeAdjMsrBlockOnIteration(), ComputeAdjustedMsrPrecisions(), ComputeandPrintAdjMsrOnIteration(), ComputeChiSquareNetwork(), ComputeGlobalPelzer(), ComputePrecisionAdjMsrs(), ComputeStatistics(), ComputeTestStat(), ComputeTstatistics(), CreateMsrToStnTally(), debug_BlockInformation(), debug_SolutionInformation(), DeSerialiseAdjustedVarianceMatrices(), dna_adjust(), FormInverseVarianceMatrix(), FormUniqueMsrList(), GenerateStatistics(), GetMemoryFootprint(), InitialiseAdjustment(), InitialiseMeasurement(), InitialiseTypeBUncertainties(), LoadDatabaseId(), LoadNetworkFiles(), LoadSegmentationFile(), LoadSegmentationMetrics(), LoadVarianceMatrix_D(), LoadVarianceMatrix_G(), LoadVarianceMatrix_X(), LoadVarianceMatrix_Y(), LoadVarianceScaling(), OpenOutputFileStreams(), OpenStageFileStreams(), OutputLargestCorrection(), PopulateEstimatedStationMatrix(), PrepareAdjustment(), PrepareAdjustmentBlock(), PrepareAdjustmentCombine(), PrepareAdjustmentReverse(), PrepareDesignAndMsrMnsCmpMatrices(), PrepareDesignAndMsrMnsCmpMatricesStage(), PrepareMappedRegions(), PrepareStationandVarianceMatrices(), PrintAdjGNSSAlternateUnits(), PrintAdjMeasurements(), PrintAdjMeasurements_D(), PrintAdjMeasurements_GXY(), PrintAdjMeasurementsHeader(), PrintAdjMeasurementStatistics(), PrintAdjStation(), PrintAdjStations(), PrintAdjStationsUniqueList(), PrintAdjustedNetworkMeasurements(), PrintAdjustedNetworkStations(), PrintAdjustmentStatus(), PrintCompMeasurements(), PrintCompMeasurements_D(), PrintCompMeasurementsAngular(), PrintCompMeasurementsLinear(), PrintCorStation(), PrintCorStations(), PrintCorStationsUniqueList(), PrintEstimatedStationCoordinatestoDNAXML(), PrintEstimatedStationCoordinatestoDNAXML_Y(), PrintEstimatedStationCoordinatestoSNX(), PrintIteration(), PrintMeasurementsAngular(), PrintMeasurementsLinear(), PrintMeasurementsToStation(), PrintNetworkStationCorrections(), PrintOutputFileHeaderInfo(), PrintPositionalUncertainty(), PrintPosUncertainties(), PrintPosUncertaintiesHeader(), PrintPosUncertaintiesUniqueList(), PrintPosUncertainty(), PrintStatistics(), ResizeMatrixVectors(), SerialiseAdjustedVarianceMatrices(), SetDefaultReferenceFrame(), SignalExceptionAdjustment(), Solve(), SolveMT(), SolveMTTry(), UpdateAdjustment(), UpdateAtVinv(), UpdateBinaryFiles(), UpdateDesignMeasMatrices_GX(), UpdateDesignNormalMeasMatrices_A(), UpdateDesignNormalMeasMatrices_BK(), UpdateDesignNormalMeasMatrices_D(), UpdateDesignNormalMeasMatrices_G(), UpdateDesignNormalMeasMatrices_H(), UpdateDesignNormalMeasMatrices_I(), UpdateDesignNormalMeasMatrices_J(), UpdateDesignNormalMeasMatrices_L(), UpdateDesignNormalMeasMatrices_S(), UpdateDesignNormalMeasMatrices_V(), UpdateDesignNormalMeasMatrices_X(), UpdateDesignNormalMeasMatrices_Y(), UpdateDesignNormalMeasMatrices_Z(), UpdateEstimatesCombine(), UpdateEstimatesFinal(), UpdateEstimatesForward(), UpdateEstimatesReverse(), UpdateIgnoredMeasurements_D(), UpdateNormals_Y(), ValidateandFinaliseAdjustment(), WriteMsrtoAdjFile(), WriteStatstoAdjFile(), and WriteStntoAdjFile().

◆ bst_meta_

binary_file_meta_t dynadjust::networkadjust::dna_adjust::bst_meta_

private

Definition at line 1082 of file dnaadjust.hpp.

Referenced by LoadNetworkFiles(), PrintEstimatedStationCoordinatestoSNX(), SetDefaultReferenceFrame(), and UpdateBinaryFiles().

◆ bms_meta_

binary_file_meta_t dynadjust::networkadjust::dna_adjust::bms_meta_

private

Definition at line 1083 of file dnaadjust.hpp.

Referenced by FormInverseVarianceMatrixReduced(), InitialiseMeasurement(), LoadNetworkFiles(), LoadVarianceMatrix_D(), PrepareAdjustment(), PrepareAdjustmentBlock(), PrepareDesignAndMsrMnsCmpMatricesStage(), PrepareStationandVarianceMatrices(), PrintEstimatedStationCoordinatestoSNX(), UpdateBinaryFiles(), and UpdateDesignNormalMeasMatrices_D().

◆ bstBinaryRecords_

vstn_t dynadjust::networkadjust::dna_adjust::bstBinaryRecords_

private

Definition at line 1085 of file dnaadjust.hpp.

◆ bmsBinaryRecords_

vmsr_t dynadjust::networkadjust::dna_adjust::bmsBinaryRecords_

private

◆ vAssocStnList_

vASL dynadjust::networkadjust::dna_adjust::vAssocStnList_

private

Definition at line 1087 of file dnaadjust.hpp.

Referenced by CreateMsrToStnTally(), GetMemoryFootprint(), IgnoredMeasurementContainsInvalidStation(), LoadNetworkFiles(), LoadSegmentationMetrics(), PrintMeasurementsToStation(), and RemoveInvalidISLStations().

◆ vAssocMsrList_

v_aml_pair dynadjust::networkadjust::dna_adjust::vAssocMsrList_

private

Definition at line 1088 of file dnaadjust.hpp.

Referenced by CreateMsrToStnTally(), dna_adjust(), and GetMemoryFootprint().

◆ bmsr_count_

UINT32 dynadjust::networkadjust::dna_adjust::bmsr_count_

private

Definition at line 1090 of file dnaadjust.hpp.

Referenced by dna_adjust(), and LoadNetworkFiles().

◆ bstn_count_

UINT32 dynadjust::networkadjust::dna_adjust::bstn_count_

private

Definition at line 1091 of file dnaadjust.hpp.

Referenced by dna_adjust(), and LoadNetworkFiles().

◆ asl_count_

UINT32 dynadjust::networkadjust::dna_adjust::asl_count_

private

Definition at line 1092 of file dnaadjust.hpp.

Referenced by dna_adjust(), and LoadNetworkFiles().

◆ debug_file

std::ofstream dynadjust::networkadjust::dna_adjust::debug_file

private

Definition at line 1094 of file dnaadjust.hpp.

Referenced by AddConstraintStationstoNormalsForward(), AddConstraintStationstoNormalsSimultaneous(), AddMsrtoMeasMinusComp(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustPhasedReverse(), AdjustPhasedReverseCombine(), CarryStnEstimatesandVariancesForward(), CarryStnEstimatesandVariancesReverse(), CloseOutputFiles(), ComputeTestStat(), debug_BlockInformation(), debug_SolutionInformation(), dna_adjust(), GetMemoryFootprint(), LoadSegmentationMetrics(), LoadVarianceMatrix_D(), LoadVarianceMatrix_G(), LoadVarianceMatrix_X(), LoadVarianceMatrix_Y(), OpenOutputFileStreams(), PrepareAdjustment(), PrepareAdjustmentBlock(), PrintIteration(), Solve(), SolveMT(), SolveMTTry(), ThreadSafeWritetoDbgFile(), UpdateAtVinv(), UpdateDesignNormalMeasMatrices_D(), UpdateDesignNormalMeasMatrices_X(), UpdateIgnoredMeasurements_D(), UpdateNormals_Y(), and ~dna_adjust().

◆ adj_file

std::ofstream dynadjust::networkadjust::dna_adjust::adj_file

private

Definition at line 1095 of file dnaadjust.hpp.

◆ xyz_file

std::ofstream dynadjust::networkadjust::dna_adjust::xyz_file

private

Definition at line 1096 of file dnaadjust.hpp.

Referenced by CloseOutputFiles(), OpenOutputFileStreams(), PrintAdjustedNetworkStations(), PrintOutputFileHeaderInfo(), and ~dna_adjust().

◆ blockLargeCorr_

UINT32 dynadjust::networkadjust::dna_adjust::blockLargeCorr_

private

Definition at line 1098 of file dnaadjust.hpp.

Referenced by AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), OutputLargestCorrection(), UpdateEstimatesFinal(), and UpdateEstimatesForward().

◆ largestCorr_

double dynadjust::networkadjust::dna_adjust::largestCorr_

private

Definition at line 1099 of file dnaadjust.hpp.

Referenced by AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), UpdateEstimatesFinal(), and UpdateEstimatesForward().

◆ PRECISION_SEC_MSR

UINT16 dynadjust::networkadjust::dna_adjust::PRECISION_SEC_MSR

private

Definition at line 1101 of file dnaadjust.hpp.

Referenced by InitialiseAdjustment(), PrintMeasurementCorrection(), PrintMeasurementsAngular(), and PrintMsrVarianceMatrixException().

◆ PRECISION_SEC_STN

UINT16 dynadjust::networkadjust::dna_adjust::PRECISION_SEC_STN

private

Definition at line 1101 of file dnaadjust.hpp.

Referenced by InitialiseAdjustment(), PrintAdjStation(), and PrintPosUncertainty().

◆ PRECISION_MTR_MSR

UINT16 dynadjust::networkadjust::dna_adjust::PRECISION_MTR_MSR

private

Definition at line 1102 of file dnaadjust.hpp.

Referenced by InitialiseAdjustment(), PrintMeasurementCorrection(), PrintMeasurementsLinear(), and PrintMsrVarianceMatrixException().

◆ PRECISION_MTR_STN

UINT16 dynadjust::networkadjust::dna_adjust::PRECISION_MTR_STN

private

Definition at line 1102 of file dnaadjust.hpp.

Referenced by InitialiseAdjustment(), OutputLargestCorrection(), PrintAdjStation(), PrintCorStation(), and PrintPosUncertainty().

◆ measurementParams_

UINT32 dynadjust::networkadjust::dna_adjust::measurementParams_

private

Definition at line 1108 of file dnaadjust.hpp.

Referenced by AdjustPhased(), AdjustPhasedReverseCombine(), ComputeChiSquareNetwork(), ComputeChiSquareSimultaneous(), ComputeGlobalNetStat(), dna_adjust(), GetMeasurementCount(), LoadNetworkFiles(), PrepareAdjustment(), PrintEstimatedStationCoordinatestoSNX(), and PrintStatistics().

◆ measurementCount_

UINT32 dynadjust::networkadjust::dna_adjust::measurementCount_

private

Definition at line 1110 of file dnaadjust.hpp.

Referenced by ComputeChiSquareSimultaneous(), dna_adjust(), and LoadNetworkFiles().

◆ unknownParams_

UINT32 dynadjust::networkadjust::dna_adjust::unknownParams_

private

Definition at line 1112 of file dnaadjust.hpp.

Referenced by ComputeGlobalNetStat(), dna_adjust(), GetUnknownsCount(), LoadNetworkFiles(), LoadSegmentationMetrics(), PopulateEstimatedStationMatrix(), PrepareAdjustment(), PrepareStationandVarianceMatrices(), and PrintStatistics().

◆ unknownsCount_

UINT32 dynadjust::networkadjust::dna_adjust::unknownsCount_

private

Definition at line 1113 of file dnaadjust.hpp.

Referenced by dna_adjust(), LoadNetworkFiles(), LoadSegmentationMetrics(), PopulateEstimatedStationMatrix(), and PrintEstimatedStationCoordinatestoSNX().

◆ chiSquared_

double dynadjust::networkadjust::dna_adjust::chiSquared_

private

Definition at line 1114 of file dnaadjust.hpp.

Referenced by AdjustPhased(), AdjustPhasedReverseCombine(), ComputeChiSquare(), ComputeChiSquare_ABCEHIJKLMPQRSVZ(), ComputeChiSquare_D(), ComputeChiSquare_G(), ComputeChiSquare_XY(), ComputeChiSquareNetwork(), ComputeGlobalNetStat(), ComputeTestStat(), dna_adjust(), GetChiSquared(), and PrintStatistics().

◆ chiSquaredStage_

double dynadjust::networkadjust::dna_adjust::chiSquaredStage_

private

Definition at line 1114 of file dnaadjust.hpp.

Referenced by AdjustPhased(), and AdjustPhasedReverseCombine().

◆ sigmaZero_

double dynadjust::networkadjust::dna_adjust::sigmaZero_

private

Definition at line 1115 of file dnaadjust.hpp.

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeGlobalNetStat(), ComputeGlobalTestStat(), dna_adjust(), GenerateStatistics(), GetSigmaZero(), PrintEstimatedStationCoordinatestoSNX(), and PrintStatistics().

◆ sigmaZeroSqRt_

double dynadjust::networkadjust::dna_adjust::sigmaZeroSqRt_

private

Definition at line 1116 of file dnaadjust.hpp.

Referenced by ComputeGlobalNetStat(), dna_adjust(), UpdateMsrTstatistic(), UpdateMsrTstatistic_D(), and UpdateMsrTstatistic_GXY().

◆ chiSquaredUpperLimit_

double dynadjust::networkadjust::dna_adjust::chiSquaredUpperLimit_

private

Definition at line 1117 of file dnaadjust.hpp.

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeGlobalTestStat(), dna_adjust(), GenerateStatistics(), GetChiSquaredUpperLimit(), and PrintStatistics().

◆ chiSquaredLowerLimit_

double dynadjust::networkadjust::dna_adjust::chiSquaredLowerLimit_

private

Definition at line 1118 of file dnaadjust.hpp.

Referenced by ComputeGlobalTestStat(), dna_adjust(), GetChiSquaredLowerLimit(), and PrintStatistics().

◆ globalPelzerReliability_

double dynadjust::networkadjust::dna_adjust::globalPelzerReliability_

private

Definition at line 1119 of file dnaadjust.hpp.

Referenced by ComputeGlobalPelzer(), dna_adjust(), GetGlobalPelzerRel(), and PrintStatistics().

◆ degreesofFreedom_

int dynadjust::networkadjust::dna_adjust::degreesofFreedom_

private

Definition at line 1120 of file dnaadjust.hpp.

Referenced by ComputeGlobalNetStat(), ComputeGlobalTestStat(), ComputeTestStat(), dna_adjust(), GetDegreesOfFreedom(), PrepareAdjustment(), and PrintStatistics().

◆ passFail_

UINT32 dynadjust::networkadjust::dna_adjust::passFail_

private

Definition at line 1121 of file dnaadjust.hpp.

Referenced by ComputeGlobalTestStat(), dna_adjust(), GetTestResult(), and PrintStatistics().

◆ maxCorr_

double dynadjust::networkadjust::dna_adjust::maxCorr_

private

Definition at line 1122 of file dnaadjust.hpp.

Referenced by AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), dna_adjust(), GenerateStatistics(), PrintAdjustmentStatus(), SetmaxCorr(), UpdateEstimatesFinal(), UpdateEstimatesForward(), and ValidateandFinaliseAdjustment().

◆ criticalValue_

double dynadjust::networkadjust::dna_adjust::criticalValue_

private

Definition at line 1123 of file dnaadjust.hpp.

Referenced by dna_adjust(), InitialiseAdjustment(), PrintAdjMeasurementStatistics(), PrintMeasurementsAngular(), PrintMeasurementsLinear(), and UpdateMsrRecord().

◆ potentialOutlierCount_

UINT32 dynadjust::networkadjust::dna_adjust::potentialOutlierCount_

private

Definition at line 1124 of file dnaadjust.hpp.

Referenced by AdjustPhased(), ComputeandPrintAdjMsrOnIteration(), ComputeStatistics(), GetPotentialOutlierCount(), InitialiseAdjustment(), PrintStatistics(), and UpdateMsrRecord().

◆ allStationsFixed_

bool dynadjust::networkadjust::dna_adjust::allStationsFixed_

private

Definition at line 1125 of file dnaadjust.hpp.

Referenced by dna_adjust(), GetAllFixed(), LoadSegmentationMetrics(), PopulateEstimatedStationMatrix(), and PrintStatistics().

◆ iterationCorrections_

message_bank<std::string> dynadjust::networkadjust::dna_adjust::iterationCorrections_

private

Definition at line 1127 of file dnaadjust.hpp.

Referenced by AdjustNetwork(), AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), and GetMaxCorrection().

◆ v_ContiguousNetList_

vUINT32 dynadjust::networkadjust::dna_adjust::v_ContiguousNetList_

private

Definition at line 1130 of file dnaadjust.hpp.

Referenced by GetMemoryFootprint(), LoadSegmentationFile(), and LoadSegmentationMetrics().

◆ v_statSummary_

vsummary_t dynadjust::networkadjust::dna_adjust::v_statSummary_

private

Definition at line 1132 of file dnaadjust.hpp.

Referenced by ComputeBlockTestStat(), ResizeMatrixVectors(), and UpdateEstimatesForward().

◆ v_pseudoMeasCountFwd_

vUINT32 dynadjust::networkadjust::dna_adjust::v_pseudoMeasCountFwd_

private

Definition at line 1134 of file dnaadjust.hpp.

Referenced by dna_adjust(), GetMemoryFootprint(), PrepareDesignAndMsrMnsCmpMatrices(), ResizeMatrixVectors(), and UpdateEstimatesForward().

◆ v_measurementParams_

vUINT32 dynadjust::networkadjust::dna_adjust::v_measurementParams_

private

Definition at line 1135 of file dnaadjust.hpp.

Referenced by AdjustPhasedReverseCombine(), CarryStnEstimatesandVariancesCombine(), CarryStnEstimatesandVariancesForward(), CarryStnEstimatesandVariancesReverse(), ComputeChiSquareNetwork(), ComputeChiSquareSimultaneous(), dna_adjust(), GetMemoryFootprint(), LoadNetworkFiles(), LoadSegmentationMetrics(), and UpdateEstimatesForward().

◆ v_measurementCount_

vUINT32 dynadjust::networkadjust::dna_adjust::v_measurementCount_

private

Definition at line 1137 of file dnaadjust.hpp.

Referenced by ComputeChiSquareSimultaneous(), dna_adjust(), GetMemoryFootprint(), LoadNetworkFiles(), LoadSegmentationFile(), LoadSegmentationMetrics(), PrepareDesignAndMsrMnsCmpMatrices(), and PrepareDesignAndMsrMnsCmpMatricesStage().

◆ v_measurementVarianceCount_

vUINT32 dynadjust::networkadjust::dna_adjust::v_measurementVarianceCount_

private

Definition at line 1139 of file dnaadjust.hpp.

Referenced by dna_adjust(), GetMemoryFootprint(), LoadNetworkFiles(), LoadSegmentationMetrics(), PrepareDesignAndMsrMnsCmpMatrices(), and PrepareDesignAndMsrMnsCmpMatricesStage().

◆ v_unknownParams_

vUINT32 dynadjust::networkadjust::dna_adjust::v_unknownParams_

private

Definition at line 1142 of file dnaadjust.hpp.

Referenced by dna_adjust(), GetMemoryFootprint(), LoadSegmentationMetrics(), PrepareStationandVarianceMatrices(), and UpdateEstimatesForward().

◆ v_unknownsCount_

vUINT32 dynadjust::networkadjust::dna_adjust::v_unknownsCount_

private

Definition at line 1143 of file dnaadjust.hpp.

Referenced by dna_adjust(), GetMemoryFootprint(), LoadNetworkFiles(), LoadSegmentationFile(), LoadSegmentationMetrics(), PrepareDesignAndMsrMnsCmpMatrices(), PrepareDesignAndMsrMnsCmpMatricesStage(), and PrepareStationandVarianceMatrices().

◆ v_sigmaZero_

vdouble dynadjust::networkadjust::dna_adjust::v_sigmaZero_

private

Definition at line 1145 of file dnaadjust.hpp.

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeBlockTestStat(), dna_adjust(), GetMemoryFootprint(), and ResizeMatrixVectors().

◆ v_chiSquaredUpperLimit_

vdouble dynadjust::networkadjust::dna_adjust::v_chiSquaredUpperLimit_

private

Definition at line 1146 of file dnaadjust.hpp.

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeBlockTestStat(), dna_adjust(), GetMemoryFootprint(), and ResizeMatrixVectors().

◆ v_chiSquaredLowerLimit_

vdouble dynadjust::networkadjust::dna_adjust::v_chiSquaredLowerLimit_

private

Definition at line 1147 of file dnaadjust.hpp.

Referenced by ComputeBlockTestStat(), dna_adjust(), GetMemoryFootprint(), and ResizeMatrixVectors().

◆ v_passFail_

vUINT32 dynadjust::networkadjust::dna_adjust::v_passFail_

private

Definition at line 1148 of file dnaadjust.hpp.

Referenced by ComputeAdjMsrBlockOnIteration(), ComputeBlockTestStat(), dna_adjust(), and ResizeMatrixVectors().

◆ v_blockStationsMap_

v_uint32_uint32_map dynadjust::networkadjust::dna_adjust::v_blockStationsMap_

private

◆ v_blockStationsMapUnique_

v_u32u32_uint32_pair dynadjust::networkadjust::dna_adjust::v_blockStationsMapUnique_

private

◆ v_ISL_

vvUINT32 dynadjust::networkadjust::dna_adjust::v_ISL_

private

Definition at line 1157 of file dnaadjust.hpp.

Referenced by debug_BlockInformation(), GetMemoryFootprint(), LoadNetworkFiles(), LoadPhasedBlocks(), LoadSegmentationFile(), LoadSegmentationMetrics(), PrepareAdjustmentBlock(), PrintEstimatedStationCoordinatestoDNAXML_Y(), ResizeMatrixVectors(), Solve(), SolveMT(), and UpdateGeographicCoords().

◆ v_JSL_

vvUINT32 dynadjust::networkadjust::dna_adjust::v_JSL_

private

Definition at line 1158 of file dnaadjust.hpp.

Referenced by CarryStnEstimatesandVariancesCombine(), CarryStnEstimatesandVariancesForward(), CarryStnEstimatesandVariancesReverse(), debug_BlockInformation(), GetMemoryFootprint(), LoadPhasedBlocks(), LoadSegmentationFile(), LoadSegmentationMetrics(), PrepareAdjustmentBlock(), PrepareDesignAndMsrMnsCmpMatrices(), PrepareStationandVarianceMatrices(), PrintEstimatedStationCoordinatestoDNAXML_Y(), ShrinkForwardMatrices(), Solve(), SolveMT(), and UpdateEstimatesFinal().

◆ v_CML_

vvUINT32 dynadjust::networkadjust::dna_adjust::v_CML_

private

◆ v_msr_block_

v_uint32_u32u32_pair dynadjust::networkadjust::dna_adjust::v_msr_block_

private

Definition at line 1163 of file dnaadjust.hpp.

Referenced by AdjustPhasedForward(), ComputeandPrintAdjMsrOnIteration(), FormUniqueMsrList(), and PrintAdjustedNetworkMeasurements().

◆ v_msrTally_

vmsrtally dynadjust::networkadjust::dna_adjust::v_msrTally_

private

Definition at line 1166 of file dnaadjust.hpp.

Referenced by AdjustSimultaneous(), CreateMeasurementTally(), ResizeMatrixVectors(), and UpdateAdjustment().

◆ v_stnmsrTally_

vmsrtally dynadjust::networkadjust::dna_adjust::v_stnmsrTally_

private

Definition at line 1167 of file dnaadjust.hpp.

Referenced by CreateMsrToStnTally(), and PrintMeasurementsToStation().

◆ v_paramStnAppearance_

vv_stn_appear dynadjust::networkadjust::dna_adjust::v_paramStnAppearance_

private

Definition at line 1169 of file dnaadjust.hpp.

Referenced by AddConstraintStationstoNormalsCombine(), AddConstraintStationstoNormalsForward(), AddConstraintStationstoNormalsReverse(), BuildSimultaneousStnAppearance(), BuildUniqueBlockStationMap(), LoadSegmentationMetrics(), and UpdateGeographicCoordsPhased().

◆ v_parameterStationCount_

vUINT32 dynadjust::networkadjust::dna_adjust::v_parameterStationCount_

private

Definition at line 1170 of file dnaadjust.hpp.

Referenced by dna_adjust(), GetMemoryFootprint(), LoadSegmentationFile(), LoadSegmentationMetrics(), and ResizeMatrixVectors().

◆ v_parameterStationList_

vvUINT32 dynadjust::networkadjust::dna_adjust::v_parameterStationList_

private

◆ typeBUncertaintyGlobal_

type_b_uncertainty dynadjust::networkadjust::dna_adjust::typeBUncertaintyGlobal_

private

Definition at line 1174 of file dnaadjust.hpp.

Referenced by InitialiseTypeBUncertainties(), and PrintAdjStation().

◆ v_typeBUncertaintiesLocal_

v_type_b_uncertainty dynadjust::networkadjust::dna_adjust::v_typeBUncertaintiesLocal_

private

Definition at line 1177 of file dnaadjust.hpp.

Referenced by InitialiseTypeBUncertainties(), and PrintAdjStation().

◆ v_typeBUncertaintyMethod_

v_type_b_method dynadjust::networkadjust::dna_adjust::v_typeBUncertaintyMethod_

private

Definition at line 1179 of file dnaadjust.hpp.

Referenced by InitialiseTypeBUncertainties(), and PrintAdjStation().

◆ v_stationTypeBMap_

v_uint32_uint32_pair dynadjust::networkadjust::dna_adjust::v_stationTypeBMap_

private

Definition at line 1182 of file dnaadjust.hpp.

Referenced by InitialiseTypeBUncertainties(), and PrintAdjStation().

◆ v_normals_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_normals_

private

Definition at line 1189 of file dnaadjust.hpp.

Referenced by AddConstraintStationstoNormalsCombine(), AddConstraintStationstoNormalsForward(), AddConstraintStationstoNormalsReverse(), AddConstraintStationstoNormalsSimultaneous(), AdjustSimultaneous(), BackupNormals(), CarryForwardJunctions(), CarryReverseJunctions(), CarryStnEstimatesandVariancesCombine(), CarryStnEstimatesandVariancesForward(), CarryStnEstimatesandVariancesReverse(), ComputeAdjustedMsrPrecisions(), ComputePrecisionAdjMsrs(), debug_SolutionInformation(), DeserialiseBlockFromMappedFile(), dna_adjust(), GetMemoryFootprint(), PrepareAdjustmentBlock(), PrepareAdjustmentReverse(), PrepareDesignAndMsrMnsCmpMatrices(), PrepareDesignAndMsrMnsCmpMatricesStage(), PrintEstimatedStationCoordinatestoDNAXML_Y(), PrintEstimatedStationCoordinatestoSNX(), RebuildNormals(), ResizeMatrixVectors(), Solve(), UnloadBlock(), UpdateAdjustment(), UpdateDesignNormalMeasMatrices(), UpdateDesignNormalMeasMatrices_X(), UpdateDesignNormalMeasMatrices_Y(), UpdateEstimatesFinal(), UpdateEstimatesForward(), UpdateEstimatesReverse(), UpdateNormals(), and ValidateandFinaliseAdjustment().

◆ v_normalsR_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_normalsR_

private

◆ v_AtVinv_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_AtVinv_

private

◆ v_design_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_design_

private

Definition at line 1192 of file dnaadjust.hpp.

Referenced by CarryStnEstimatesandVariancesCombine(), ComputePrecisionAdjMsrs(), debug_SolutionInformation(), DeserialiseBlockFromMappedFile(), dna_adjust(), GetMemoryFootprint(), PrepareAdjustment(), PrepareAdjustmentBlock(), PrepareDesignAndMsrMnsCmpMatrices(), PrepareDesignAndMsrMnsCmpMatricesStage(), ResizeMatrixVectors(), Solve(), UnloadBlock(), UpdateDesignNormalMeasMatrices(), and UpdateNormals().

◆ v_rigorousVariances_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_rigorousVariances_

private

◆ v_measMinusComp_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_measMinusComp_

private

◆ v_estimatedStations_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_estimatedStations_

private

Definition at line 1196 of file dnaadjust.hpp.

◆ v_originalStations_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_originalStations_

private

Definition at line 1198 of file dnaadjust.hpp.

Referenced by CarryReverseJunctions(), DeserialiseBlockFromMappedFile(), dna_adjust(), GetMemoryFootprint(), PopulateEstimatedStationMatrix(), PrepareAdjustmentCombine(), PrepareAdjustmentReverse(), PrepareStationandVarianceMatrices(), PrintAdjStation(), PrintCorStation(), ResizeMatrixVectors(), SerialiseBlockToDisk(), SerialiseBlockToMappedFile(), SetRegionOffsets(), UnloadBlock(), UpdateAdjustment(), and UpdateEstimatesFinal().

◆ v_rigorousStations_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_rigorousStations_

private

◆ v_junctionVariances_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_junctionVariances_

private

Definition at line 1202 of file dnaadjust.hpp.

Referenced by CarryStnEstimatesandVariancesForward(), CarryStnEstimatesandVariancesReverse(), DeserialiseBlockFromMappedFile(), dna_adjust(), GetMemoryFootprint(), LoadSegmentationMetrics(), PrepareAdjustment(), PrepareStationandVarianceMatrices(), ResizeMatrixVectors(), SerialiseBlockToDisk(), SerialiseBlockToMappedFile(), SetRegionOffsets(), and UnloadBlock().

◆ v_junctionVariancesFwd_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_junctionVariancesFwd_

private

Definition at line 1205 of file dnaadjust.hpp.

Referenced by CarryStnEstimatesandVariancesCombine(), CarryStnEstimatesandVariancesForward(), DeserialiseBlockFromMappedFile(), dna_adjust(), GetMemoryFootprint(), LoadSegmentationMetrics(), PrepareStationandVarianceMatrices(), ResizeMatrixVectors(), SerialiseBlockToDisk(), SerialiseBlockToMappedFile(), SetRegionOffsets(), and UnloadBlock().

◆ v_junctionEstimatesFwd_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_junctionEstimatesFwd_

private

Definition at line 1206 of file dnaadjust.hpp.

Referenced by CarryStnEstimatesandVariancesCombine(), CarryStnEstimatesandVariancesForward(), DeserialiseBlockFromMappedFile(), dna_adjust(), GetMemoryFootprint(), LoadSegmentationMetrics(), PrepareStationandVarianceMatrices(), SerialiseBlockToDisk(), SerialiseBlockToMappedFile(), SetRegionOffsets(), and UnloadBlock().

◆ v_junctionEstimatesRev_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_junctionEstimatesRev_

private

Definition at line 1208 of file dnaadjust.hpp.

Referenced by CarryStnEstimatesandVariancesReverse(), DeserialiseBlockFromMappedFile(), dna_adjust(), GetMemoryFootprint(), LoadSegmentationMetrics(), PrepareStationandVarianceMatrices(), SerialiseBlockToDisk(), SerialiseBlockToMappedFile(), SetRegionOffsets(), and UnloadBlock().

◆ v_precAdjMsrsFull_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_precAdjMsrsFull_

private

◆ v_corrections_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_corrections_

private

◆ v_correctionsR_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_correctionsR_

private

Definition at line 1213 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), GetMemoryFootprint(), PrepareDesignAndMsrMnsCmpMatrices(), PrepareDesignAndMsrMnsCmpMatricesStage(), ResizeMatrixVectors(), SolveMT(), UnloadBlock(), UpdateEstimatesCombine(), UpdateEstimatesFinal(), UpdateEstimatesForward(), and UpdateEstimatesReverse().

◆ normals_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::normals_map_

private

Definition at line 1223 of file dnaadjust.hpp.

◆ normalsR_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::normalsR_map_

private

Definition at line 1224 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ AtVinv_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::AtVinv_map_

private

Definition at line 1225 of file dnaadjust.hpp.

◆ design_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::design_map_

private

Definition at line 1226 of file dnaadjust.hpp.

◆ measMinusComp_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::measMinusComp_map_

private

Definition at line 1227 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ estimatedStations_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::estimatedStations_map_

private

Definition at line 1228 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ originalStations_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::originalStations_map_

private

Definition at line 1229 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ rigorousStations_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::rigorousStations_map_

private

Definition at line 1230 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ junctionVariances_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::junctionVariances_map_

private

Definition at line 1231 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ junctionVariancesFwd_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::junctionVariancesFwd_map_

private

Definition at line 1232 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ junctionEstimatesFwd_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::junctionEstimatesFwd_map_

private

Definition at line 1233 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ junctionEstimatesRev_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::junctionEstimatesRev_map_

private

Definition at line 1234 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ rigorousVariances_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::rigorousVariances_map_

private

Definition at line 1235 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ precAdjMsrs_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::precAdjMsrs_map_

private

Definition at line 1236 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ corrections_map_

vmat_file_map dynadjust::networkadjust::dna_adjust::corrections_map_

private

Definition at line 1237 of file dnaadjust.hpp.

Referenced by DeserialiseBlockFromMappedFile(), OpenStageFileStreams(), PrepareMemoryMapRegions(), ReserveBlockMapRegions(), SerialiseBlockToMappedFile(), SetMapRegions(), and SetRegionOffsets().

◆ v_stageFileStreams_

vstring dynadjust::networkadjust::dna_adjust::v_stageFileStreams_

private

Definition at line 1239 of file dnaadjust.hpp.

Referenced by OpenStageFileStreams(), and PurgeMatricesFromDisk().

◆ f_normals_

std::fstream dynadjust::networkadjust::dna_adjust::f_normals_

private

Definition at line 1240 of file dnaadjust.hpp.

◆ f_normalsR_

std::fstream dynadjust::networkadjust::dna_adjust::f_normalsR_

private

Definition at line 1241 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ f_AtVinv_

std::fstream dynadjust::networkadjust::dna_adjust::f_AtVinv_

private

Definition at line 1242 of file dnaadjust.hpp.

◆ f_design_

std::fstream dynadjust::networkadjust::dna_adjust::f_design_

private

Definition at line 1243 of file dnaadjust.hpp.

◆ f_measMinusComp_

std::fstream dynadjust::networkadjust::dna_adjust::f_measMinusComp_

private

Definition at line 1244 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ f_estimatedStations_

std::fstream dynadjust::networkadjust::dna_adjust::f_estimatedStations_

private

Definition at line 1245 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ f_originalStations_

std::fstream dynadjust::networkadjust::dna_adjust::f_originalStations_

private

Definition at line 1246 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ f_rigorousStations_

std::fstream dynadjust::networkadjust::dna_adjust::f_rigorousStations_

private

Definition at line 1247 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ f_junctionVariances_

std::fstream dynadjust::networkadjust::dna_adjust::f_junctionVariances_

private

Definition at line 1248 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ f_junctionVariancesFwd_

std::fstream dynadjust::networkadjust::dna_adjust::f_junctionVariancesFwd_

private

Definition at line 1249 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ f_junctionEstimatesFwd_

std::fstream dynadjust::networkadjust::dna_adjust::f_junctionEstimatesFwd_

private

Definition at line 1250 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ f_junctionEstimatesRev_

std::fstream dynadjust::networkadjust::dna_adjust::f_junctionEstimatesRev_

private

Definition at line 1251 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ f_rigorousVariances_

std::fstream dynadjust::networkadjust::dna_adjust::f_rigorousVariances_

private

Definition at line 1252 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), DeSerialiseAdjustedVarianceMatrices(), OpenStageFileStreams(), SerialiseAdjustedVarianceMatrices(), and SerialiseBlockToDisk().

◆ f_precAdjMsrs_

std::fstream dynadjust::networkadjust::dna_adjust::f_precAdjMsrs_

private

Definition at line 1253 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), DeSerialiseAdjustedVarianceMatrices(), OpenStageFileStreams(), SerialiseAdjustedVarianceMatrices(), and SerialiseBlockToDisk().

◆ f_corrections_

std::fstream dynadjust::networkadjust::dna_adjust::f_corrections_

private

Definition at line 1254 of file dnaadjust.hpp.

Referenced by CloseStageFileStreams(), OpenStageFileStreams(), and SerialiseBlockToDisk().

◆ iterationQueue_

concurrent_queue<UINT32> dynadjust::networkadjust::dna_adjust::iterationQueue_

private

Definition at line 1257 of file dnaadjust.hpp.

Referenced by AdjustPhased(), AdjustPhasedBlock1(), AdjustPhasedMultiThread(), AdjustSimultaneous(), GetMessageIteration(), and NewMessagesAvailable().

◆ v_designR_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_designR_

private

Definition at line 1262 of file dnaadjust.hpp.

Referenced by dna_adjust(), GetMemoryFootprint(), PrepareAdjustment(), SolveMT(), SolveMTTry(), UpdateDesignNormalMeasMatrices(), and UpdateNormals().

◆ v_AtVinvR_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_AtVinvR_

private

Definition at line 1263 of file dnaadjust.hpp.

Referenced by CarryStnEstimatesandVariancesCombine(), CarryStnEstimatesandVariancesReverse(), dna_adjust(), GetMemoryFootprint(), PrepareAdjustment(), SolveMT(), SolveMTTry(), UpdateDesignNormalMeasMatrices(), UpdateEstimatesCombine(), UpdateEstimatesFinal(), and UpdateNormals().

◆ v_normalsRC_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_normalsRC_

private

Definition at line 1264 of file dnaadjust.hpp.

Referenced by BackupNormals(), CarryStnEstimatesandVariancesCombine(), dna_adjust(), GetMemoryFootprint(), PrepareAdjustmentBlock(), and ResizeMatrixVectors().

◆ v_measMinusCompR_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_measMinusCompR_

private

Definition at line 1266 of file dnaadjust.hpp.

Referenced by CarryStnEstimatesandVariancesCombine(), CarryStnEstimatesandVariancesReverse(), dna_adjust(), GetMemoryFootprint(), PrepareAdjustment(), SolveMT(), SolveMTTry(), UpdateDesignNormalMeasMatrices(), UpdateEstimatesCombine(), and UpdateEstimatesFinal().

◆ v_estimatedStationsR_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_estimatedStationsR_

private

Definition at line 1267 of file dnaadjust.hpp.

Referenced by CarryReverseJunctions(), CarryStnEstimatesandVariancesCombine(), CarryStnEstimatesandVariancesReverse(), dna_adjust(), GetMemoryFootprint(), PrepareAdjustment(), PrepareAdjustmentCombine(), PrepareAdjustmentReverse(), SolveMT(), SolveMTTry(), UpdateAdjustment(), UpdateDesignNormalMeasMatrices(), UpdateEstimatesCombine(), UpdateEstimatesFinal(), and UpdateEstimatesReverse().

◆ v_junctionVariancesR_

v_mat_2d dynadjust::networkadjust::dna_adjust::v_junctionVariancesR_

private

Definition at line 1269 of file dnaadjust.hpp.

Referenced by CarryStnEstimatesandVariancesReverse(), dna_adjust(), GetMemoryFootprint(), and PrepareAdjustment().

◆ v_blockStationsR

vUINT32 dynadjust::networkadjust::dna_adjust::v_blockStationsR

private

Definition at line 1273 of file dnaadjust.hpp.

◆ v_msr_db_map_

v_msr_database_id_map dynadjust::networkadjust::dna_adjust::v_msr_db_map_

private

Definition at line 1276 of file dnaadjust.hpp.

Referenced by LoadDatabaseId(), PrintAdjGNSSAlternateUnits(), PrintAdjustedNetworkMeasurements(), and PrintMeasurementDatabaseID().

◆ _it_dbid

it_vdbid_t dynadjust::networkadjust::dna_adjust::_it_dbid

private

Definition at line 1277 of file dnaadjust.hpp.

Referenced by PrintAdjGNSSAlternateUnits(), and PrintMeasurementDatabaseID().

◆ databaseIDsLoaded_

bool dynadjust::networkadjust::dna_adjust::databaseIDsLoaded_

private

Definition at line 1278 of file dnaadjust.hpp.

Referenced by dna_adjust(), LoadDatabaseId(), and PrintAdjustedNetworkMeasurements().

◆ isCancelled_

std::atomic<bool> dynadjust::networkadjust::dna_adjust::isCancelled_

private

Definition at line 1283 of file dnaadjust.hpp.

Referenced by CancelAdjustment(), dna_adjust(), and IsCancelled().

The documentation for this class was generated from the following files:

dynadjust/dnaadjust/dnaadjust.hpp
dynadjust/dnaadjust/dnaadjust-multi.cpp
dynadjust/dnaadjust/dnaadjust-stage.cpp
dynadjust/dnaadjust/dnaadjust.cpp

Public Member Functions

Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ dna_adjust() [1/2]

◆ ~dna_adjust()

◆ dna_adjust() [2/2]

Member Function Documentation

◆ operator=()

◆ ShrinkForwardMatrices()

◆ CarryForwardJunctions()

◆ CarryReverseJunctions()

◆ PrepareAdjustmentMultiThread()

◆ PrepareAdjustmentBlock()

◆ PrepareAdjustmentReverse()

◆ PrepareAdjustmentCombine()

◆ BackupNormals()

◆ UpdateEstimatesForward()

◆ UpdateEstimatesReverse()

◆ UpdateEstimatesCombine()

◆ UpdateEstimatesFinal()

◆ UpdateEstimatesFinalNoCombine()

◆ GenerateStatistics()

◆ PrepareAdjustment()

◆ CancelAdjustment()

◆ IsCancelled()

◆ GetStatus()

◆ IsPreparing()

◆ IsAdjusting()

◆ ExceptionRaised()

◆ PrintAdjustedNetworkStations()

◆ PrintPositionalUncertainty()

◆ PrintNetworkStationCorrections()

◆ PrintAdjustedNetworkMeasurements()

◆ PrintMeasurementsToStation()

◆ PrintEstimatedStationCoordinatestoSNX()

◆ PrintEstimatedStationCoordinatestoDNAXML()

◆ PrintEstimatedStationCoordinatestoDNAXML_Y()

◆ CloseOutputFiles()

◆ UpdateBinaryFiles()

◆ CurrentIteration()

◆ incrementIteration()

◆ initialiseIteration()

◆ CurrentBlock()

◆ SetcurrentBlock()

◆ SetmaxCorr()

◆ blockCount()

◆ adjustTime()

◆ processingForward()

◆ processingCombine()

◆ GetDegreesOfFreedom()

◆ GetMeasurementCount()

◆ GetUnknownsCount()

◆ GetChiSquared()

◆ GetSigmaZero()

◆ GetPotentialOutlierCount()

◆ GetChiSquaredUpperLimit()

◆ GetChiSquaredLowerLimit()

◆ GetGlobalPelzerRel()

◆ GetTestResult()

◆ GetAllFixed()

◆ GetMemoryFootprint()

◆ LoadSegmentationFileParameters()

◆ SerialiseAdjustedVarianceMatrices()

◆ DeSerialiseAdjustedVarianceMatrices()

◆ NewMessagesAvailable()

◆ GetMessageIteration()

◆ GetMaxCorrection()

◆ ThreadSafeWritetoAdjFile()

◆ WriteStatstoAdjFile()

◆ WriteStntoAdjFile()

◆ WriteMsrtoAdjFile()

◆ ThreadSafeWritetoDbgFile()

◆ AdjustNetwork()

◆ FirstBlock()

◆ LastBlock()

◆ SignalExceptionAdjustment()